diff --git a/src/dstr-binding/default/async-gen-func-decl-dflt.template b/src/dstr-binding/default/async-gen-func-decl-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..1f7045cd81c2f7e6a41eddc381b246cc9a5af6e4
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-func-decl-dflt.template
@@ -0,0 +1,27 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/statements/async-generator/dstr-dflt-
+name: async generator function declaration (default parameter)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+async function* f(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-func-decl.template b/src/dstr-binding/default/async-gen-func-decl.template
new file mode 100644
index 0000000000000000000000000000000000000000..0eeb3eae209127dd35c71fb8c918d3d3a29d4630
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-func-decl.template
@@ -0,0 +1,27 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/statements/async-generator/dstr-
+name: async generator function declaration
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+async function* f(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+f(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-func-expr-dflt.template b/src/dstr-binding/default/async-gen-func-expr-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..c514a6aa96d02411650f29299fd5965636f9caa9
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-func-expr-dflt.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/async-generator/dstr-dflt-
+name: async generator function expression (default parameter)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var f;
+f = async function*(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-func-expr.template b/src/dstr-binding/default/async-gen-func-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..09e743cba2993279c16b00b1b3dea35c008851fa
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-func-expr.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/async-generator/dstr-
+name: async generator function expression
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var f;
+f = async function*(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-func-named-expr-dflt.template b/src/dstr-binding/default/async-gen-func-named-expr-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..e7bec27226bd50ebe9d3f97274b51d7dad3ae4b1
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-func-named-expr-dflt.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/async-generator/dstr-named-dflt-
+name: async generator named function expression (default parameter)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var f;
+f = async function* g(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-func-named-expr.template b/src/dstr-binding/default/async-gen-func-named-expr.template
new file mode 100644
index 0000000000000000000000000000000000000000..8f064343b1e1a282d06e925720389da9778f20b9
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-func-named-expr.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/async-generator/dstr-named-
+name: async generator named function expression
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var f;
+f = async function* g(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+};
+
+f(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-meth.template b/src/dstr-binding/default/async-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..71142977d840b434f863c911df61f213bfad2c73
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-meth.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/object/dstr-async-gen-meth-
+name: async generator method
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var obj = {
+ async *method(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/async-gen-method-dflt.template b/src/dstr-binding/default/async-gen-method-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..c0c98a853e50036d93b2dae38fbe5554be3d3e17
--- /dev/null
+++ b/src/dstr-binding/default/async-gen-method-dflt.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/object/dstr-async-gen-meth-dflt-
+name: async generator method (default parameter)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var obj = {
+ async *method(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template b/src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..ab50758df8e5f9bc551e235bf8cfd9a08c760334
--- /dev/null
+++ b/src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
@@ -0,0 +1,53 @@
+// 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/dstr-async-gen-meth-dflt-
+name: class expression async generator method (default parameters)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+class C {
+ async *method(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template b/src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..2fc323229d1bd2533eaa319fa63c92799f52d48a
--- /dev/null
+++ b/src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
@@ -0,0 +1,53 @@
+// 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/dstr-async-gen-meth-static-dflt-
+name: static class expression async generator method (default parameter)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+class C {
+ static async *method(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-decl-async-gen-meth-static.template b/src/dstr-binding/default/cls-decl-async-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..8586b9227c3f5c947399bc7a05cd7ad01c6ce0bb
--- /dev/null
+++ b/src/dstr-binding/default/cls-decl-async-gen-meth-static.template
@@ -0,0 +1,53 @@
+// 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/dstr-async-gen-meth-static-
+name: static class expression async generator method
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+class C {
+ static async *method(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.method(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-decl-async-gen-meth.template b/src/dstr-binding/default/cls-decl-async-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..d326b878c7d30d80a455c0a1069fdf127dc7b5e5
--- /dev/null
+++ b/src/dstr-binding/default/cls-decl-async-gen-meth.template
@@ -0,0 +1,53 @@
+// 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/dstr-async-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+class C {
+ async *method(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(/*{ vals }*/).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template b/src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..4e0acac1ed6acf35de936d5b2540ea3b6a926b60
--- /dev/null
+++ b/src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
@@ -0,0 +1,54 @@
+// 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/dstr-async-gen-meth-dflt-
+name: class expression async generator method (default parameter)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var C = class {
+ async *method(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template b/src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
new file mode 100644
index 0000000000000000000000000000000000000000..3dbcf59e2abf27bbf5eed523879965ef3cb96769
--- /dev/null
+++ b/src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
@@ -0,0 +1,54 @@
+// 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/dstr-async-gen-meth-static-dflt-
+name: static class expression async generator method (default parameter)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var C = class {
+ static async *method(/*{ elems }*/ = /*{ vals }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-expr-async-gen-meth-static.template b/src/dstr-binding/default/cls-expr-async-gen-meth-static.template
new file mode 100644
index 0000000000000000000000000000000000000000..003cd8cb353d75afb42770cbc8831ffcd277adf5
--- /dev/null
+++ b/src/dstr-binding/default/cls-expr-async-gen-meth-static.template
@@ -0,0 +1,54 @@
+// 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/dstr-async-gen-meth-static-
+name: static class expression async generator method
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var C = class {
+ static async *method(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+C.method(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/src/dstr-binding/default/cls-expr-async-gen-meth.template b/src/dstr-binding/default/cls-expr-async-gen-meth.template
new file mode 100644
index 0000000000000000000000000000000000000000..5ef3e6228e5c0c5c8ac728a584d1768bb6b266e2
--- /dev/null
+++ b/src/dstr-binding/default/cls-expr-async-gen-meth.template
@@ -0,0 +1,54 @@
+// 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/dstr-async-gen-meth-
+name: class expression method
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+flags: [async]
+---*/
+
+var callCount = 0;
+var C = class {
+ async *method(/*{ elems }*/) {
+ /*{ body }*/
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(/*{ vals }*/).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-init-iter-close.js b/test/language/expressions/async-generator/dstr-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba461d82f0fe3d50437f7694a132d824b483d1cb
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-init-iter-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-init-iter-no-close.js b/test/language/expressions/async-generator/dstr-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..d86532d87ecad7dfd73fd14eea2cb8b43828452a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-init-iter-no-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-name-iter-val.js b/test/language/expressions/async-generator/dstr-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..499de0116a9cf1537a635d030f8a9d1b22d772be
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-name-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..eea31a9237f5a67b0e2f9cd0430ba2d98254bab6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6eebf4c3785b251e814a9c24043dbda9202cddf
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+};
+
+f([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..4766ead717bbc5d81d8f8fc5ad594a0dc7664f97
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a3e8c806217f771bf31b11333ea9fe70ee0dcf4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+};
+
+f([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..e467b90ae50d5a2494b7cde5457b58e8e24094ad
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var f;
+f = async function*([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbadf985138143844f9ef17e253c9a763098bdb6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function*([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..c7bc031e09479e9c7d83dd087c38ef218609bb45
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var f;
+f = async function*([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..67152696b923a0759a21678ddea8564c655f5205
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function*([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..234b837c9c6817abadefeff1ded3cee945367ce0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..65ff61312c68cbc13c2f1456812d187f3c80be45
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb6d8428561092cff8fec523c5fd6262b48211b6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..802ef044a98566d22891bd4a8dfd070ec8b1c4ce
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..228b817cff9fadb7d4b326abe17ebbcdffdfa8fc
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..944929879a3c6b3b6a89c5949ea5596c40a1e8f5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c344d82edf135fc3b15e6e95352aba1e262714f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Destructuring initializer with a "hole" (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+};
+
+f([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..99049e281c77b8d5ff6cea03c39210ea53662af8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..3cbda93d3406a728cd712dfeeee618795d2ef0d2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Destructuring initializer with an undefined value (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..e031bd113b52f3f6bba84e70501e9f5223355029
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..f52c076ddddb49bb6f3f7570ebd4ab6d0fb4be51
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..1708ece4a0258fa8b0f85d3358c22df7528a7cb5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..f03a02917acddc92b3c21a066b0ee7ff9c7115c9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2cde7d069a8436f9f933726634689aec39ff7832
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+};
+
+f([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..962719c17ac3c71e298f38d4478423f321a2bf22
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..51f2765c69d302a5fa89fbfac0fa6314bf2c0412
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elision-exhausted.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..89b330aa6c5ccb6b793ac064ce16bd7044174034
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Elision accepts exhausted iterator (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var f;
+f = async function*([,]) {
+
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-elision.js b/test/language/expressions/async-generator/dstr-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c6a167c42fe2b49ae0679813046520b031467f6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-elision.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Elision advances iterator (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-empty.js b/test/language/expressions/async-generator/dstr-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..513938bc4dfc834068bda480ca611fd7b567aa20
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-empty.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function*([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-elem.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..3c43df5608b38cc16d3cf6423e1c79a8cb774d40
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+};
+
+f([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-elision.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..598074ff3f09af2cec3f13396872d497012a3b89
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element containing an elision (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+};
+
+f(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-empty.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..0826952b5d2b93bc046debaa1021a9d7da0ecaeb
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function*([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-rest.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..e92b336c1451ba7a90e6e92161c77da5c4acc2b9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element containing a rest element (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function*([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+};
+
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id-elision.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..777cb98cd72e0ce9e7913cc9e125a617a856f09e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element following elision elements (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var f;
+f = async function*([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..629393e1941fcbb58fb9544df1d61b5bc92ec234
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+};
+
+f([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..310b819baa13254bd9261055ae6567b2e738f057
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Lone rest element (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function*([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-ary.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2f2a7215f2aa075163ee6c97383a924e318bdbd
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8d252bab6d2c561ef7657bde34fdc754df2649f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...x = []]) {
+
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-obj.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..21dc82f665ff8ce1d88f49e41eaa3b84d86a389d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ x } = []]) {
+
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..0cb4c8e8d5b5f4bb2fc6b0d278c3aec10c364a57
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...[x], y]) {
+
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d523387fd01229cc31a5d7cd0d8dc38e507dd885
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...x, y]) {
+
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fb1b7881047b6827486cdfcdf358db2e942d53b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ x }, y]) {
+
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-obj-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..1eb76bee63d347403e81fb54a2eef66913f4cf85
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element containing an object binding pattern (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4fd7cb2fe7a89958f50df98f39d9439e2d34cc7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest element containing an object binding pattern (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+};
+
+f([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-init-iter-close.js b/test/language/expressions/async-generator/dstr-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..e966ce5891b9fdb7804321b5be16fbe54634e4c4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-init-iter-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-init-iter-no-close.js b/test/language/expressions/async-generator/dstr-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..dfb9dc9676f7f566170c7988b08aa5930306a7c6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-name-iter-val.js b/test/language/expressions/async-generator/dstr-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..288df23bfa1c70b8fa6fdf0ea00a965023999ce6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-name-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..1001f14112283b36b45dfe4a5b34cf7b167ec290
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..dbe29a46407c7e126a4dc20b6f0a604a7ad845d9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..b2c5d08638a3a264560e8a233679115b29d58416
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4c865a703399739698572d7d517132308afc79d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc559bcfc1943f75494c4d70750363f1910fce57
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var f;
+f = async function*([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..fac6ae4e58595896eec5f23a39b9b265d15abdac
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function*([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..c7decc0f90ce5e19c2d23b542ea311cce2d9655d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var f;
+f = async function*([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..46f0bc0b6201f31394151126b3c5ebb26541baaa
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function*([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5ca7e62cc021e55038137f1540d9fa3064ded07
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..d488959a342530cb0b89f1ed0ed04525b3225ca2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..6cd170d20ffd193d62c4e5d0fff1cb8d8fb38e6c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f3bded604543874f06d5718267f14027e8dd59a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2985313e341f7f781ce2c42f66865c24d908d8c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a96e50a77527d7efc3ae6560e2e9778925f2539
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f4197b717c73119de9c97a150a08512d74485e8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e26f280c50d508df4ed75fdfc645e311aae1938
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e36e3fd8a3bde598cfe9aafeff683537b0013e8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..b2fd3381d6411e8e9a66ebe86becd0d03792bd38
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..998516018578c658e88edd1787fae88ee259a25d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..57b5d635994132b3ef878cda30d16c3be3059b3b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..e5b5589e77ba94841cf653bbf23ff332a95226e4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..938f844d847cb934e5adfca0500a06597ff542b0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b0ac87f41a9467126aeb6642eb06511ffed9281
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..aae58838021b238922ff15dd40e37df928016856
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elision-exhausted.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..e29cea22c59e53f3ebebab379bfc358c154f2b08
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Elision accepts exhausted iterator (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var f;
+f = async function*([,] = iter) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elision.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f6e7e573903cd0435dcf90299656dee61c8999d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-elision.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Elision advances iterator (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-empty.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..f661e0cc61d4c1a77b74131c4fc67be78a0f44bd
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-empty.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function*([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-elem.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..774e2845649ee92e714d15e5053dd861eccf3e58
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-elision.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..8917f1e348c0583aa42677b102f54cee71a47112
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element containing an elision (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function*([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-empty.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d7d8573abee3590e1b606e1951be83105657f87
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function*([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-rest.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2948a7c6bd317db8f4937b3686bc76f90b79098
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element containing a rest element (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function*([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id-elision.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..b100baa90ee1733fab3e3441e68265c84d1ed154
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element following elision elements (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var f;
+f = async function*([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..f56afb87a969fb044013302a5adcab378d848717
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..77d3894cd9d4b21d85590decaf63bf7dbd0b6203
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Lone rest element (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function*([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-ary.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..fadd8c7e780bb5c68f899baecbb53032c68b56a0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c63a78e2161fec02df13fa150eb3a720c6bfc5d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...x = []] = []) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-obj.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..60b24fb978c9e023c2ba37509da8f1628fb459fc
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..a767c963ad8a718758be2efbc73fa79f4e5ff177
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..af8fc48d7d62be24e17606666d19d6485d2fdc5e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..c055c1430219e51cf66a59a25a10f1cc922e35e3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-obj-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..5cf0342f80d7b8fbefacb301205fe4943b43d3a3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac09037c40f023366ab6cbe6d75b34f61cc0854b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-empty.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..edda21b43fe65b6af1fb385c95cedf63730edc8c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-empty.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var f;
+f = async function*({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0374bbda82c3dddd9b34567f0294497d22b47c3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd457153bba9ec71b7ade8f8a0331edb3de54370
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9b41907659542523ffa53cff3ad755765e18d8c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..76bfa748b4746931591a155fa9bfe563838ee9e6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..efc10e9170376937251add51017ccfce670cb931
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-skipped.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..6bf59018e70298be3a8dc7670cdc51dbaccc41e7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..65e480d47e8af352afe3019e766c2c727cd16d53
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary-init.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..a0008a691b79b8be92e4de11fb0ddb590ec2585e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..578a772d62a9a8d56164d786356945ef7065f53a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f53b8489f65e9d99644a0d1e753277ca9f7ebd0a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad2572a8a03289e62342157be154596c548b9631
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-init.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..bebdf9055ea5a8bf4ba762e56762b71eb22de3e1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..5fcf4c2985d66d3ddcd1101878695aaf13d3bda9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..1156dd09cb944a6b1c71d2a5981f6b5817bb2cf7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Binding as specified via property name and identifier (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-obj-init.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea16f611d50a70ccdce5901140eb23255052b97a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-obj.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..60e1c0eb47d18f93f0ceb617b33761abe72e0857
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-getter.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..a37a15a0ac234a4314c0f3ccbb1242ddb4217280
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var f;
+f = async function*({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-nested-obj.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..d176cbdf4670ef6dc62264911c41487281290e23
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var f;
+f = async function*({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..2f8f46f414f8b334cff81f47789758013d008ae8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..442ec11e55d96364119fc826b8bed6c1a78d85cd
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var f;
+f = async function*({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c7159b5c0969f9adf7c4685c58f1ac79802e19f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var f;
+f = async function*({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-val-obj.js b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..26417192122939927ea2ed525716cfdff0bb2832
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-func-expr-dflt.template
+/*---
+description: Rest object contains just unextracted data (async generator function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-init-iter-close.js b/test/language/expressions/async-generator/dstr-named-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..c492a039e32f4a04561f071aab47851a9a9b752e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-init-iter-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-init-iter-no-close.js b/test/language/expressions/async-generator/dstr-named-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..b4ef60a6fdd11f9bbc8c5a764741d3e4c7d0fcaf
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-init-iter-no-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-name-iter-val.js b/test/language/expressions/async-generator/dstr-named-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4237ac76dadab8509efdeba66e0dc3f4b285474
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-name-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..43fcbaf45d2a7edf32eead09186467262f1062a3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c00558e71608c1434f8670c8e555ddcd5a83aeb
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+};
+
+f([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..62af41cba5c441a009c69c2c1b36a4f127943531
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ce7bf56528fe4b115b0ca821aa7343cd33d6b19
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+};
+
+f([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..4eb1851f928fdb75ebe52f6d71b6f87c106965f3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var f;
+f = async function* g([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..ec796c01dd3c22890975eac052dd5f4f7743918b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function* g([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..d2484801a50006d8473cf8e6dc7b54ed7ce551b4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var f;
+f = async function* g([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..791b302e31c4563e048d740599f8d29e59edbf09
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function* g([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..63552a2501ffa4fe235aa894a93a49a918d133af
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..55071488ab7fcd189b7b123ca6e5fce6050790f9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3c35ed419ad4805b018e221e26accf48642daa1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc6791e05bb2ccccaf98adcec13a418ef3895106
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..a96c4cfdc78bf4a1b7170b051fff7e8384e793f2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..9dd4f15587a1e243c7de4e9248193a8ff17a09a7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..bde0d44d0e90e7ae56c8ef0b9d3fe4765c67fa16
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Destructuring initializer with a "hole" (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+};
+
+f([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..454d8be9935fc5baaff2735ed2b3a8722233fa27
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..ca450f0f5498003e3a13a25abe1e008298f6f88d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Destructuring initializer with an undefined value (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..903604376c8902b908d9e22a147594a1de2f4958
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ff6a6c03327c549db6ad8521da112f43b98b5d9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..38d24244b48946e60887f54b3ef441a89437aaa2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ca5184f1ab3a3ec4f7d3dd2eea67f1e4eed73918
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..387631336d81ddc8c9fe4a3cdc42e4ad2051c882
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+};
+
+f([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..29cd75b50ad22cb0cdeb3b0106db968edf96301d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..9cff313ff2070a54cb61467acf93313e94fb83cf
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elision-exhausted.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e093ab12d22e956ed4c7394babb494cb092e67e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Elision accepts exhausted iterator (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var f;
+f = async function* g([,]) {
+
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-elision.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..721d4f7dda41d55089f4d10c4174ad945576a1c8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-elision.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Elision advances iterator (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-empty.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a97bf22077f079528bd6c6eea5c59600c059fc7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-empty.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function* g([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-elem.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..d8d4782e717691d203aeaa34bab9cbda6ea4f3e9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+};
+
+f([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-elision.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..4523ec4d4c71fef5fd98c2fa1397625a2d6ceb10
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element containing an elision (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+};
+
+f(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-empty.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa464b8ce0be69236a9be5fb7ec35b5692cfcb45
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+};
+
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-rest.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..d846b87c10acfa05f5a12a60a58fd2767c993f45
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element containing a rest element (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+};
+
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id-elision.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b1e80646a4c8ba61fc0ca27c6c8910381074e90
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element following elision elements (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var f;
+f = async function* g([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ed4bda8402f6c3b495f7d55168619bdc57eb5d7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+};
+
+f([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe8fc09850797b09ee0a94f84f6d513605beafbb
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Lone rest element (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function* g([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-ary.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f373de273a9d77e7d7872fd44a0bbc37cbd2db4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d4502d0426f1f229b371da6d46429c629bddccf
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...x = []]) {
+
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-obj.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ea051975d23173dc30c3c94c3525820fb1958aa
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ x } = []]) {
+
+ callCount = callCount + 1;
+};
+
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd29d569c6fe47ec8d44ab25dd9de9062bec1218
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[x], y]) {
+
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbbe220627d2a194e5208ce8ca593854f68f06c2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...x, y]) {
+
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a72c7c6377835ca74f3e7bdae8759f0dae9d3165
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ x }, y]) {
+
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-obj-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..7fa97b64c31a592f35b212dbd49726812e81f00e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element containing an object binding pattern (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+};
+
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..e3ba1e9949a122999e9f456380df16fbab331cdb
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest element containing an object binding pattern (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+};
+
+f([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-init-iter-close.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7b655f606fc9b6e8962ef3a76e2c52decb8100c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-init-iter-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-init-iter-no-close.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..6fcb36404ab595e72122d49f2defe2ad9c329838
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-name-iter-val.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..6713809acc1bdd283b89890118faa63c5b00d131
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-name-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..40effb6ae61b6f28a110f90279f7619bf6fbb610
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..35c0ff453fa99d0d1fb3c33ae8cd9f02dac9226a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..086f2610b7de97e881cf6ce8e518ae671924ffc5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3d89adcd93acedf984e1833a99df0b9b9e64a61
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..59071d0b15dd3dbd06f46b9fdf4276462a071436
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var f;
+f = async function* g([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc12ea7320cb6ae23dbf6c3b38934596cdb1e8b9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function* g([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ccb51fc5a8d35127bd7180ccd03a1b5233873a05
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var f;
+f = async function* g([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..6088959a5305b1b769cc26e8a01a8a2e3bc90355
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var f;
+f = async function* g([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d79c8c074053020f52e3ef3ae4683a8943b26a9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..21f0bdf38c7d84c7f9d6c75640fb090bb7c432c1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2c4c507d30c08cc83b09f5b77d1e496be322403
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..0209d355146329853901805294f75d83eaef5b25
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d4e9fadc758cc7eac89a17a69676a67ba4126f9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..b4d0443a253626f26e0b129d3d3cd5a3696abb9f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..5bf7f3c7f04b651f04052774814a8ab068fd0754
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b4c934254b3feb4fc41749402ddce0a5bd4c64a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..23148fcad633f7a6663e8fce6eb5a8b6574ad991
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d3d3cd6c2b4bc17efed2317cad3a032c32ad98e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce7dc34880dbd1489d504dc2b41d7115e69f166f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..26ea236e42692275f7f81050d8ab8fdac3fd172c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..001137991b36be62a56bc3cb0916a6f7fc064cf2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..da3fd02aad3e364736ac92cdb4c096ba53ab64e0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..39e9fbff9a5d6c6fb77641f31c2677b9f8d6de1a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c72686cdbf307cab63309d86bb478028f211fd7
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elision-exhausted.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc3fbbfca6493369b158b62a2ec58b02c6a2b9d6
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Elision accepts exhausted iterator (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var f;
+f = async function* g([,] = iter) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elision.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1f3309fc9e533e5d9addf3325408b60e35198c2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-elision.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Elision advances iterator (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-empty.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..38e75ffcbf40cb143076a8c1f1e985214859d8d0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-empty.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function* g([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-elem.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..a73aa10625317db4bc22741da6609ee025b63d9f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-elision.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..99f68ef4327638981fa626242340bda34a119803
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element containing an elision (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-empty.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..7076d3f1f482c86c4a4456e333ac206cb8fb4e78
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-rest.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..591ff84411c956ed839199790022610e49d470ed
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element containing a rest element (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id-elision.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..54899439bb1c5a3560cafa13fb037f94228af037
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element following elision elements (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var f;
+f = async function* g([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..35ab0e8e3150545a49ed239ee6977f259b71e4a1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3931178beb08f985c3026e30e02cadb1f68ec1d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Lone rest element (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var f;
+f = async function* g([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-ary.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b6a54157021a3801b34330ea546944e108177d1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..f081466ebfe9f63587348f5f21e8fb2fa5793eee
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...x = []] = []) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-obj.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..7482c06bbd7b3be2cc1f9db164f2f8660b179fc8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f164096a5f2fa5b6b0a5420b4d5e8c377006a8ef
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..65b0bc7fec1d5be8705d1de0c863ea8a5422b3bb
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..06a0b81650e9da85cfc5b3826296bea1a30b3ff0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-obj-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..396ced753e7ad26204c22ad9722457552625c773
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d81c63c00f91bb39577bc75f14ae984c13e73880
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-empty.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..22f93fe4f759effe653978279e3d082f5067f399
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-empty.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var f;
+f = async function* g({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..920bfb3ffd5b85cb6805dfa7877395f3e5712e9b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a3ab9abd2af09887cf1309b6c8bf391086c2e93
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..9fbc293b817d931307154b1c84506400b1ec58d2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..0fa23abdbc14759ca800f093c8e4226bbdd0b342
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ba403e6e0e8f14a5a6adf7aa47c9c6db0d8ef81
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-skipped.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e8bab67aa9d88b0857394c6c5ba1a656a331fa9
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..542751c921d4afc97c58d8f8a3e439b38194ffe4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary-init.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..623126eeb7d0cf18d538690ec01604e4f741f2b0
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd709a72c4fa0df8ab46e7548a518844c80f0de1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..339cb40412ba0f341c0f2ec9c528db2d8f4dda39
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..831129254992133f01bfe35d83dff1a462b3be5f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-init.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..bac87d8b2a12d6abf3c6400d951fdd88dbb69d7a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..120c8864cc05ebdfad6c2826d6702201eab367cf
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad446cbfbe158f1ed45e7f69d181b791f9e52a19
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Binding as specified via property name and identifier (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-obj-init.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d3c841189e6b79a35611940f1069f3c11d9be70
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-obj.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..5213fdbd46afc8867f405d8a6edb28c098c5beac
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-getter.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..d24fc34c632484b123668fa018531ed3bdcbd911
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var f;
+f = async function* g({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-nested-obj.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..8deb75ad0a0eb1fe85582b3e4fa93bca7f7c6c20
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var f;
+f = async function* g({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..214120a141b669fb3088bc898ebffcde788d7812
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..8530eb693534e1aa17c3f3defb50e86240f50c57
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..0934e60b84f5227958f4e0473da9e6bb7fbbb0b5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var f;
+f = async function* g({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-val-obj.js b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..30b2aafe13143baf02a6620c503e8e59a6e803c8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr-dflt.template
+/*---
+description: Rest object contains just unextracted data (async generator named function expression (default parameter))
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+};
+
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-empty.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a64471d76d255f9209119e7ae4ad7933fc97f18
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-empty.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var f;
+f = async function* g({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+};
+
+f(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..dce02d43479428e485d596d8f1cfdf1730fbed24
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc09344708803d85fba7abfb1d8b6ccd08f4b582
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9d138ed1f43bb4b9189bf1fb36dc8608300ef0a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..8aa56d73fe0d05da246825a7d515a5ea56dc0eac
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..4cbb3a83f4869bb7c9f181653053e9ce3edcdbe3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-skipped.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..0dc3982ea7bf4f275316531f73930b60a20fb05b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e323eba8f8e6aee9b5ab7aa2eaade788c7b281b
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary-init.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..3551c495ce8aa349d5637cab82e9b1ed8a9f37f4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..b15620034d26865dd0e3471264a4c3c644ea3299
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+};
+
+f({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..bee5b84e0ca7081a0f03516c1dc3ff7c942041c5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-ary.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..51a9d5ba18eb771ab977ae9522f48cf938181b5a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-init.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a8c40091696ca11e18224b705eb531937df730c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-init.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ab068c14a68810d021964a2016baef7947b4512
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..44ceddf56a4ae9905907707ac663c6273513da27
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-id.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Binding as specified via property name and identifier (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-obj-init.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9ecbeb6e289e326d26653c189f6cf9e80c97d94
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-obj.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..fba95b709d34de35c0702d4555f6533eee346b9f
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-prop-obj.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-getter.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..331f83333640e46351e70cdd50c52138586337a2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-getter.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var f;
+f = async function* g({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+};
+
+f({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-nested-obj.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..73cdc466a5f81593002ffa4c89ad77b3fdbb34c5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var f;
+f = async function* g({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+};
+
+f({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e499172eec14149f293132cb9e3cbf874660298
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+};
+
+f({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..33ff58b9062fca4279de08603bb7b3d3befd80f3
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var f;
+f = async function* g({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+};
+
+f(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..074e85de5abc0636d0bd18fb5931b61a691148cd
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var f;
+f = async function* g({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+};
+
+f(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-val-obj.js b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..789ae2c0b90d59203ac42078ca35e2993f6c6d9d
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-named-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-func-named-expr.template
+/*---
+description: Rest object contains just unextracted data (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, funcEnv, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function* g({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+};
+
+f({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-empty.js b/test/language/expressions/async-generator/dstr-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..240160001f5b968c89dbe6f1ad9066021f135c6c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-empty.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var f;
+f = async function*({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+};
+
+f(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..84f6a329db7a80c330504b32117e8dcc69b232a8
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..d8f998ed246cdbeb3cb7020b867eb94019f00492
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee03204628b67bf7fa7e465d405d1496ef5464ef
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd85796993b2a343987ff3975680d465c3adf518
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..a822663727fa83a74388f4bf38b436681d077f8e
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-skipped.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b5b423d1a3f73ad053010fb104845407190c033
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+
+f({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d79ef0026ef97d91d84756db84b522db55b9bb2
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary-init.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ffcfcb494f2aebd473991f072ee770870988dc8a
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..4276cc0ec5e4aec3bc3b05b40a195a3210845fb5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+};
+
+f({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..0dfe5903cd06cd134d62f63b9aa8a16d195f29c4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-ary.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..35cf7f857e13eaba858b6da58b513e78e25d0405
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+
+f({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-init.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e3a18b457b664462d8bb91d7f8ab01c037cdbdd
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-init.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d8c17ac440950e9943d27d26e0409a7407959c5
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2759f8415677db6a9c380d237b22e39a2213c1e1
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-id.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Binding as specified via property name and identifier (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-obj-init.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..7351870286ade3bd243084d153ca165dfb8adac4
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-prop-obj.js b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a3ecab45e8ca16a2987969d817ae37488e5ef36
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-prop-obj.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+
+f({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-rest-getter.js b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..51cdb2192433784666ae5d90b42ff62de43286ce
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-getter.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var f;
+f = async function*({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+};
+
+f({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-rest-nested-obj.js b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f15a4c4a61c4f1f7d875fea90d39821af16244c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var f;
+f = async function*({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+};
+
+f({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..485bca78b1a2fdf331fc992002d50a6aab898e56
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+};
+
+f({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..a7df802e33e0ece5bcc24f33789b36b9a1ec1b72
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var f;
+f = async function*({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+};
+
+f(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1f2000439adb4f7c4fa32566a6f4c9f67ffeb55
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var f;
+f = async function*({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+};
+
+f(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/dstr-obj-ptrn-rest-val-obj.js b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..c473c96b81c08f9c16f66c9d0dbb325285a38d5c
--- /dev/null
+++ b/test/language/expressions/async-generator/dstr-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-func-expr.template
+/*---
+description: Rest object contains just unextracted data (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+ AsyncGeneratorBody }
+
+ [...]
+ 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var f;
+f = async function*({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+};
+
+f({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-init-iter-close.js b/test/language/expressions/class/dstr-async-gen-meth-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..36a8e1c042e38e3136b9ec51e31826a84ad6bbe2
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-init-iter-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-init-iter-no-close.js b/test/language/expressions/class/dstr-async-gen-meth-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..4721fd38a1904bd5c78aba178d9a41cb031d169b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-init-iter-no-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-name-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba5907a1e7e170a4fbe04b07441762bac32e6cef
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-name-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding with normal value iteration (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..be43c3d8839bdab71b50f4ffcbe61789414ab4e9
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..abd902dd8e9957c3de2db8bd26fe9dcfd2e31eb3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..31b60c9f9a376e472f8d321556468e469ab64a23
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9fb1fec06150b0161f31ae619aa657ddede0b4f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..955c21cf0fb6e4c7770b5cc26e41db34a215631d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var C = class {
+ async *method([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6c136cd90ade38b0e7ce2669d894b54836c61d9
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ async *method([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..f257312876e12c3e73d909b1c6ec28aa9bfe76b5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var C = class {
+ async *method([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..577648d9054f6c7c054b67fbeabeb8b85b5e3b3f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ async *method([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..21db37fcd334d4e9afc19b703d8b85910a3ef43d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Destructuring initializer with an exhausted iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee96db4bab5cb5884a809b7f772c7ea9298d408c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1c2082e9ac4b3da64ffafed582720218e29f2aa
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ab753efed3fa81e33fe555dfaac40f270a6e431
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..e14a7075509dfda341d1d71e2f0cec35e65116d1
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..35443cf796f6ac83a7dba96336f17cb28c52bac5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..698a6b3ca5e3f7c862fa4af12260cba1ce52a20e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Destructuring initializer with a "hole" (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..50317451fb8f438ed6ac3c66609c55432af25e3b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ async *method([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..f1f50faa387aa24f7ad2ddb17ec110339bef279f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Destructuring initializer with an undefined value (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..72991c27c4e93b1169f3bf1661a1069c7841a74d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration completes (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9f3df4636050c803a9b5b943eb97652f23bbf60
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..82b45138c891c3f39be070849ca2c5659445ac1b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe6087acfb69235ccad7f334976f721abe3f41d5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..910d018c12439b8042358b1769e60b4aea2b87e5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd8ed97437289c19023cdc0566a9aaf9fe5baef5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..f885023a84cac4f6c80ce9d65e6f27e075d92770
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..5125b9d76cf7ec1bf0ec07df6cfcfaf378e2ed9c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Elision accepts exhausted iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var C = class {
+ async *method([,]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elision.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..6bf156179588dba1dc36c1d16446f73abc1bdc59
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-elision.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Elision advances iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c47369e737b3f09024619932acd8b07f6194cf5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ async *method([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..32de9cf6e8ddf75dc7081f6d771a2263d7de20c3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,90 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element containing an array BindingElementList pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf27d4936a4a636ea19914bc7105564507a5b13b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,96 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element containing an elision (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..14a84af801b07b031c30292611f69001d2e01a60
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element containing an "empty" array pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..7bef02832c891b6e965b1fec0b02bdfd9ce51324
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element containing a rest element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..e047d698a0d24d875c0d05f9be965bc759c048af
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element following elision elements (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var C = class {
+ async *method([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..008b951dc0384953e3f495c80d7c9ef90e330da4
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: RestElement applied to an exhausted iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6fd4704cf109f45c2aa29f856276889d128ff77
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Lone rest element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ async *method([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..18edf05c82fe028de3c53e99c5357c3ec57be1d0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..8cc3711551d83a244f66231e3005972bb0bd650f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Reset element (identifier) does not support initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...x = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a0ed7f0e805ac2d3484eb6df39d459af25f7495
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ x } = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..385d7493b89ef128627c1c33024dc40dc7f0096d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[x], y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..059bac7c28376604d6c2c8218d842610ffdcfc87
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element (identifier) may not be followed by any element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...x, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2d2d6c34f3b3c4c79b7c293e4b1836a6c9e642e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ x }, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..f807c6fdbff3f371a2892f9c423e0f6409da4140
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element containing an object binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..3163b8bc1b8f93f7f2530ba5189214bfe3e122e6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest element containing an object binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-init-iter-close.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..27a9cf23320d22029b5dd5db4a22dd7f8e022d79
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-init-iter-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..eed7371736ba3c855e7519a1018b25ffea615c66
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-name-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..3dc38f9177ff8a781a3f6414bb17d3871370b322
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-name-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f3e600a9e17f7f7eb6013307fa5ebe17e58a9be
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbdb77320b393ee1224f1d99d0d07788f7e44804
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..be3fc1b9ab78fa3e3a6b04d7193a60645f28fd94
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..534cdc8ab410ce672e450401afb50d2d14110637
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..8163e94d18753d05de51e16dfd7ed48bfffe5d00
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var C = class {
+ async *method([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..eabac854f8a789772941ee8a2330e0caabe6305a
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ async *method([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..36950728e97fa66d21c5307ea00e8e759dd23fd8
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var C = class {
+ async *method([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..e62af86f32c5fc3622ff70fbe1b7fbf43ea1597b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ async *method([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef0862481ae096df6bd5475ea095d64f5239099f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..50be953f91c3392aaecfdcc955c728da2dab2437
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..e141b57341201141c63f16da32bf491829a59c6b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..b1091d6dc1ebc5e35924d190975eecf1860dc6b2
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a69dca1e80873866ab198914bd09bfe292585ac
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..357704c8f1db47b2c71c1a43499f1fc904a1d455
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..0840c48f0f094b072f0e1f64ca0f2da1582c6485
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ca818894d996416ca0cb50dd6f9ff775f3cd633
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ async *method([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd65a5b222b3cd004eb607a6e3935cd1ac0e736a
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..c14e949291e1d490df0f86218df5463858e685d6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..611cd1b5300ec90abf481b4bf4870143685c5fde
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..39de6a7655ddc2336f48f06d7e150df106e72628
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..a743254fca9939f134e53c44ad2ba7e0b547c78e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..5317dcc149d25c55b909e97c8b0091288f99867c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d21068a6526b76df2395081e101766ea4ab3e2b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..42945ca6470ab9b5624bb2366345fe4a8cb6c05c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5cadb5cb20eec0b56989f88a071ecd37caf2271
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Elision accepts exhausted iterator (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var C = class {
+ async *method([,] = iter) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elision.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..aebcea6c5029c5e4f53b914cd51094b369939baa
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-elision.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Elision advances iterator (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2bbc04334b386e5fa3ec3c0764a4fbfd67ae1b0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ async *method([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..74f8543f622fa1d061fc27cdc96ffea1974e592e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,90 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..64f8436f31d4af1bd49831bc0014850c5703ddb6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,96 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an elision (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..66575057ab10d4bc3417486d9143e3c367934d4e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..adaaabe56fc91a31b09a19efe6b956861c7a4ab1
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element containing a rest element (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..e71a2cd3a31f7027dc0b7faacc7912894d96a01e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element following elision elements (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var C = class {
+ async *method([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..96fc35d9916681b4ae12758d5ae4e5166131e768
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e33126e5992e6b11ead4145befef63a0c6d9257
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Lone rest element (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ async *method([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..d148f581cc5143bc15296524d5623aa969965dee
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..ca88618de8eb1d13bbcb2a90f2fb63e967a89a85
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...x = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d6b8c55d7406124139b2f7c17374a5374e5a2ac
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..a89ee1089b4b29d7fa4bef1e857c974c91b3ef57
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..1bf578b6b17c5849745926765f68fc1ae1885a4e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..b9e346aa62c7da4bf24ab732b790e2c36457c1ac
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ff043fd93f93388ca4ad523ff3eaf8a05735dc5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an object binding pattern (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..083dea0f7b76ddfd77d47ac58c085e17ef3dc4d1
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an object binding pattern (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..a4b91d6ac94c4058142d784120ac277425ed2a81
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-empty.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var C = class {
+ async *method({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc7ffd08241282000c2eab9641270f6c166bc84e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..6799beb53edbb08975f62cb8d12c21022d2007dd
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..aaad99ca4e245ce868ba4932be50bf800458108f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..b63144a2e4e44a4c515fed3d2a138330667d14ef
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..8115fca5bd26100f76b97e79cf8fdae8f8945c1b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..04fb5fd4dde1af20d72c8841d216faffea8f8ebe
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..c39b588bc17e39aa6102932932426eb3e2a86fc6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ff581de13a71dc4730933f856c7ea93fb827500
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b7105b25d89bc48f1ed574b4bf57c402de2d834
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..4eacea4edb306ccdb0d1aa7f8d72c1ca0b6fea3e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..9fbab5342f568944d2661fcf8243f5409882aad6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e3bef2937b0a231974c1275a87d1469f6ebd3a0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..3befceb3ec8b96d127893e56ce68b4c7dcdfd4ae
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d43c9832980bb38f8c6bfc1d84701b6fd03aa24
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Binding as specified via property name and identifier (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..0617bc954fd64f4f9e3cf1d185dc509965b7145e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..532e1e2daf5e6c2b8e0a81cd48f31df617715925
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d42d4c3b4b2969ce03d4591b849480aba86d431
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var C = class {
+ async *method({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..195d5719a76532be2b0a9d1466bb2317414eb1fb
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var C = class {
+ async *method({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..7304aa2c131b7b59d1a6d1d9559f543b4d38bafb
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f0a905f9b25bf8242e0e72cb71278e8648175ae
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c7a899d3731da41a811b71f746bff0bb277b588
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var C = class {
+ async *method({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ab89e94441bfda5263772d2154535475fe70965
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-dflt.template
+/*---
+description: Rest object contains just unextracted data (class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..d308275cfa612227b30192ac3929a8b5943ef4f7
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-empty.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var C = class {
+ async *method({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f7004cc450a7a556118bd78b0ede9120b1b4a2e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..be19e63d854028e48b83b28641238be7f2d956a9
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..d78fa89dde2cc4ae9da0320a7ff0e40cf8056550
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..e55c73ad2da98f91fc0726595b2ecfa19ed5b048
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..11da07c1b8061315a62b4acae39e584f0867a90e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..0cc981d7bf7fbc8a841327c4bf0529da96d550b5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..bb6ba0377c4c0699a8ab8b6e6dd86a14b9f561fb
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..60f6c989e9702fd0fba2aa2624869d0c42e37928
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..09100cc94134ff319bd8856a212213653543f520
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..7711f02cbc07ab9f198053ce9bd4cea69d524411
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-ary.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..01b5131b9e7c364b22e13a0986cfc5f7e9253b33
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..da1e2cd11288450614235fdd2e7f4aa279637d7d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-init.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..92fe6d79522b7522d55ed50adbf32375eaf8ab60
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..c501a870d613a8bec61cdf6b150a02deb13101de
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-id.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Binding as specified via property name and identifier (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..907bb079909561939a5a5871dfbc5b634b4ecb11
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-obj.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..bb6797ce69155fae8e881d0b88fa769deb6b92a5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-prop-obj.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-getter.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ec6be2994176b867fc092481d7ac8d0d896ae2d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-getter.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var C = class {
+ async *method({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..b25826340843dfcd5df84bc3e59ff794a95d6356
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var C = class {
+ async *method({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..3b7fab8d36feaac79a89abbcb904e498dabfd60c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..60af16c0591d1628fc8c77ef8c6a7dcea2ba6770
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest object contains just soruce object's own properties (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var C = class {
+ async *method({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..e61725d7ffc349fb55badfbe1770f725bb49724f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var C = class {
+ async *method({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..82973b03c3386efdc825cbd029acf49159f2e347
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth.template
+/*---
+description: Rest object contains just unextracted data (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ async *method({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-init-iter-close.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..64b1fbcc1ff8eb8ca0feabd15d089053c05a29ae
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-init-iter-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-init-iter-no-close.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..349006afab48731d32a48cc5e490f72e0ef89431
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-init-iter-no-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-name-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..8423127ee9e821b29fbdc5222c98824a85bec03f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-name-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding with normal value iteration (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc4f9ae90543a15e45444b7d30e40c37a60b9018
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..8756a88d50802cbb45a15bf1e79f50ca20b6a857
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fb310ab003f9de6b87466af2f19a813629daf34
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..da19c02dc79e5c716da541b8bfce2190525038b1
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b3422c65211995c3b45f8ee962125360f559795
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..b2c5b7a03477eb1fdeecb9170279e8152fa0fd3f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..e42d26c79108a9cd08d6acd25f6fcac01e7251bf
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..e880fefce12a4dd4c12389c8b4118b0c12b0f761
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..3fd6b3a401e368458f3ed5c78f35fff3ef40e41e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Destructuring initializer with an exhausted iterator (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..65de318232f93c10793585210314fe99c5f4dc01
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac174bca49c55f326584e62d26cd0435131c86ca
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..101abd46333fc1fbfbf46f624b72758473808f52
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..dadfe97ae39a355e6a8882c434716c6078b718e7
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..a984f8f96feb648e30c9d37bc7b29f417577a98a
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..9dca70bd9420903941dfd505b198189a94ee9474
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Destructuring initializer with a "hole" (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+C.method([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..9854b882c4038e1aaab7601b1fc6908bcbcbd742
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ static async *method([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..39e6c7cee1d3f3d610c1bd6fbbbeecf1fc71bdf0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Destructuring initializer with an undefined value (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f4bf30daff7ca7c132c2b867df6d65cac183734
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding when value iteration completes (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..90e5796746b23a9bb7000e7871d3cfb4fede1f33
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..2acd50098a536e444693f97add267458bd05b902
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..30738173a022ac27f97c5dabf52ab594edbbfcce
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..530e9b7845558f657b4b6091a4632b4b8a59068b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed11b2c3564006def24f4fd848c09dd75a49787c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c486fe0b033870aad31a0010aae68776d23f1d0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elision-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..499b7d4cfd94a4bdabdf7dd6654b87cc9da58fb6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Elision accepts exhausted iterator (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([,]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elision.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..63c68b98b739647423d7edcb0190ba7474cc87c0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-elision.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Elision advances iterator (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb1874312fcd93e433aa6ddd1785f2af86fe6829
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elem.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..a535622c982e33ee88fe6e8f0f9ab1f40bbc94c3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,90 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element containing an array BindingElementList pattern (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elision.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b17e8568c93504d78f7496dec5e9bd861f946b3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,96 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element containing an elision (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-empty.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d73f5214c468c9dd6b9ad62df704cc62f5a302b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element containing an "empty" array pattern (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-rest.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..dde452ba32ca0eed553a21b99b837878a874a979
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element containing a rest element (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-elision.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b407706275065f37181d45d3f1ef4c4e2769a51
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element following elision elements (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..657cc57b6df9af0461b66080bfab999e4e67c845
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: RestElement applied to an exhausted iterator (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..337711992f0460b8e6ad1906258b5618612b473a
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Lone rest element (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-ary.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc0672c7abcdff63143c7f69df42760f71cea51f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..b8c194da7722c671199eaa9fa676d3ae81570a6d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Reset element (identifier) does not support initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...x = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..021274ab46d43ff2cd22b037c706e0dc158dcdc9
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ x } = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..73cb96c84793183c7ff24d871b5efc1adf25cd80
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[x], y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4e94ec64a439c5be2341935038f428a960dd6e7
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element (identifier) may not be followed by any element (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...x, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..c773260eeb85b68784e2a72845ef5387925c22c5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ x }, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..cde509b7880d01af1d0e9eb23fd8408667d58c11
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..3f24b5b0f35d5203c162724efd8e8a45c5319f73
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-init-iter-close.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed415d7eb3d26d4242632738391c44937a81cf58
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-init-iter-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-init-iter-no-close.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d6713abab532325f9d5f89ac0e599d15257d30b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-name-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..d8c7b55a680a0b0da3a40c7bc562d7ba383a6fe6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-name-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c386e9e4f7e6747fc630916861a6500cc1ab696
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..90b68d8b194ee5eaa1d65fe163d7ef562c0b7ca3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1d1c0736c9f6591abeb36c20a16b2c0739a4ed8
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..b86ebe788582e002ac27b68b5bbbf701ddc3b65d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..b7cd352146209ebe4b8ad0c07a6274c2af44bd53
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..04b7a9e3356b9decc45092a2dd0aaf285fec7f6f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..8397e09c82e19e29c8e37182f4917bf6a2414c0d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c64e54aa0342cc0fccaef2346efffbf12b05076
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var C = class {
+ static async *method([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..50d7aedbd37899a75e5d69232326d28959efcb8e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b2cb8b7b942acda9d75e9ef5aa84bacf85320c3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..075a60d207c116fc2cf1d7fd92561d36b5c34433
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..71820f839c220332f637eddeee995dfa6c7c3538
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3e8c6a3a02f80b5b5f578a062b6d248665631fa
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba0cda478695b7efc251aed7421e504843b19066
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..02747084b6be9bb4a0ce6dd714819e8bdba591c1
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b492e7fa6e51f3f360d67ae1f0b965676b6a546
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ static async *method([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ba21cd6f5bbb04299ffbba582a8ebdb16640ad0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..99627fed0753007d42675adffa314030973bc139
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..501576a67085e6a8572fb71541c3adcdfc220ad5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..afe9e62dd73867aaabfe10cda000ab1376211eef
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..46cd8ab3a1fd0b4508f8c0383eaaa9e016f3926f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ef0e57406adc5a8aa4df364cd74ea76a384e31f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..85acd2824ea7c704be7e182b4f4819fc6fed5d1d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..96ac0b0318d053358df7235a4652480c18730c3d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..6fe69aa30b28ed4255741db59f68e1cd31a8233b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Elision accepts exhausted iterator (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([,] = iter) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc43b8d24eb9b2a0fbacdb2e0fc938609560265b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Elision advances iterator (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..609ac7f1307b3327051d50bc91107d35824614f5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ed53b0f34064508977e8434ba54232da65dbdf6
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,90 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..b1f3653c6ce94a5717f61be0586afb7c77b59be8
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,96 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an elision (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..55fb51d14872b009c726f34439a4cc346eefcb29
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b8fa344c023ec2db2d2cf47e0525dfd46345a31
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing a rest element (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..02758599fbb8e1439afde8036e004f1376a993d4
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element following elision elements (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..afbbc09bd0ddfdf9f0805994ca86a197aa9bf9ae
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..88b2d27e43bb611bdd7523fbbd5e5a8912e8b215
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Lone rest element (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..66992474e035efe636c80ae5b668efd45431cf46
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..09f3c28d72707ce0a541648b2698865742a8cfac
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...x = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b5462333cf0be922a4a803a02fe80ffbc83310a
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..870a596652314829d61e3549ffb1bc6ccbb65fab
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..0649353af3c2bbb4d698dbb6ae9d50f9df100bd9
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..106b3cf68bfc46435ec1a406a015a63ff3f89dc7
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..901443d353e53d60f10eb82bd4bc0337c669e4f0
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..32d88bded5be517b5a773c4bd650f575f1064048
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..a94492d4ca73c66147ca39bb46d54676eae15b69
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-empty.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var C = class {
+ static async *method({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..005d95d41f30376894ef4f0f2359b5c2e4a095fa
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..56467a920ea0dfb64063603e8e5abae53390d458
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..d9cf9bd5656cb551b99b5cd47d419653bc9c8461
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..01b38758c9395b37d31ea3ecb76271228698520e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..21ca8bf46144866319e6aa9822f4d6ca37f52406
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..f23bfe659146bddb2c55a9ceb9a9d61cc0406c09
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..bfaf2b457944c646742bf595b7464538c2420d5f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..f58f54a486e099e54647a3267388dbb28e047412
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fa134165e3177ceb679dde10c374fbb4a403f05
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f19dd0990e01383442d09f14275b1ad5e073280
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb431c6c580386df56602d9060b160e60d608a44
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..155fe351150e404c6ac9b673cdb8ed51da045a00
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..71f83dd81f36582a44f8549a59252e920359a24d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..16e1667b2a7371466e49ad50d1dd255f8e383ad5
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Binding as specified via property name and identifier (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..e023ecc1098e863af2b5416ba372124d5e1bc049
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..807699e1486558d27cbf316c4d03b04b70b3cc9c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-getter.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..259257170029847772641446b5b885a8e900fada
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var C = class {
+ static async *method({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-nested-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a94f4426514132e9058598a35efe389a8cbb378d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var C = class {
+ static async *method({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3600f2feb4d9e55e4d448f016fea4bf910f1124
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..c79762ab822975a6b28f08eed179e35b64c00c8e
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..be47e2743d429c18767da1deeaa6f0a75166aa24
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var C = class {
+ static async *method({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..69ac1d56c8cbd981fd5b9e7d3bb10a0c27a17535
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static-dflt.template
+/*---
+description: Rest object contains just unextracted data (static class expression async generator method (default parameter))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-empty.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..88fac39d0447f8cbf5be0d869d7174d2eff20270
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-empty.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var C = class {
+ static async *method({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..b637db8590fed543448b9b00c4049b45c7644fa7
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..f67714bf61189e23b68378af799cddd68edbb11d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..03978a446019042c75d44e18ea98155dd61d728b
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb5538e1b42212631dcaacda5a31a16be7d44267
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..f84d6e3c1b59983c44f668d1e13da428b17813dc
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ed5b67edbe5e57fdc1a88f75fbf1f1a0f2fc012
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf44093156353a43a2f2a2ba778b9f32e9fd993d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..c23e79e31d3519bfee9819df83fa7df108bcb06c
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..5853c47d4b9be533ef13d7ab7b13473616268ade
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..b796147f59115191ffd2aa33e4a16a643979d4c3
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a5ebd3dc4f275b66c58442dbc44193410559821
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..7cbd9b643935c0edb3ecf3782d9b3b7dfb3791ee
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..806bb2b839c4399e8d179ca48e20244b4cf80039
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..42e9262125b1d0f55c0c24edb89184fd71262053
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-id.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Binding as specified via property name and identifier (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj-init.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..584e939c6a59fdae9ccb109a7a63392bb80c37ad
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..20b4a06c96fcc02d8f7632ea9e9767aca4c0259d
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-getter.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..8404cf22c181e18fc0ef338ef7da5426f57c41e1
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-getter.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var C = class {
+ static async *method({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-nested-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..21df513c14c1ae1eb0828e51c5933d9148bb125f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var C = class {
+ static async *method({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..662f61a6e9c1941a849f49a15e12fb4a948938fe
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..66e312d824d3d1b154f3ef5c92e508ef9973b74f
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest object contains just soruce object's own properties (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var C = class {
+ static async *method({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..792346def3a11030c11183310aebc6f9868bc883
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var C = class {
+ static async *method({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-val-obj.js b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..f474c9d17d5282ca98ca2f709ed3046ef564a1c2
--- /dev/null
+++ b/test/language/expressions/class/dstr-async-gen-meth-static-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-expr-async-gen-meth-static.template
+/*---
+description: Rest object contains just unextracted data (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassExpression : class BindingIdentifieropt ClassTail
+
+ 1. If BindingIdentifieropt is not present, let className be undefined.
+ 2. Else, let className be StringValue of BindingIdentifier.
+ 3. Let value be the result of ClassDefinitionEvaluation of ClassTail
+ with argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation
+ for m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var C = class {
+ static async *method({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-init-iter-close.js b/test/language/expressions/object/dstr-async-gen-meth-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..e19bcf28f4fbca73717c35f2c63fe42134b538f9
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-init-iter-close.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-init-iter-no-close.js b/test/language/expressions/object/dstr-async-gen-meth-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d0787e58099ee26ada57b7d2010ac96815427e0
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-init-iter-no-close.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-name-iter-val.js b/test/language/expressions/object/dstr-async-gen-meth-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..480ebbae65a0a6822721c14730f329c8b75ad74f
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-name-iter-val.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b1159563bcd1001d07866534e594035bc361731
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..97edbdabcaee8cabec9f9e79ed5a9b37bdaae006
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b6801a73867eb474f581b0819063eed2cb20d18
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..09994b091e04cbb50d07d737e48d2841d4e9c461
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa7c038162f4966e65f8754a902369148f077e9b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var obj = {
+ async *method([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..0cfe75ce9d15d0b2aaff9eaf1f8b8514d3b1cfbb
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var obj = {
+ async *method([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6aad35c9d616e39969a1029c7eecb6695b966227
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var obj = {
+ async *method([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a0149c560d7b4745aa2ace38af0563f1069584d
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var obj = {
+ async *method([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..f960fc433be09ae8c87665042f49ef648089b349
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..971f59b80c88a963f9660838e5db5cd918c27f07
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2efbe4e2006cbfcfec2f146c58cfb117c2f777a
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..436827f664a1bf683d1b08791be7802bae5b995b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..37fe061be4f0cf8dbd6a8971e528c392ee19d5e2
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..12d34c1cdef8b8e8d65cfe784a8c6ee38d3beb3c
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e3f3c4d9160796b2b929609c947cbf5aaa81989
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Destructuring initializer with a "hole" (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..028b9e47f6094d9dcc1a26c858c3959d1812db71
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var obj = {
+ async *method([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..37e6498b8fc30cc486630bf7977b891b819af9c9
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Destructuring initializer with an undefined value (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..c93c01c34e1a6ec5518e25f7ad88a03684a36523
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b6c1e9951136e06990bb5bfe2829583605ac999
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..81d14b61bc0aeb8ff452052b24b27288427a54ce
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..68489f874818be4422bcd744c8c0abc242aa7f27
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e09c59ea257d19c07dbdca6f938a51765136c14
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..20f6681d89d6ebc7cd7aa7fe674d7f036cb34bc8
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..fab7573f17f050a652bc1cd52fc31504eb44c79a
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3ff1150a5016f8f9bf0d9c78ef518ad518f21d7
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Elision accepts exhausted iterator (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var obj = {
+ async *method([,]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elision.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9376b846017b7405280126724c81d275ffa6de4
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-elision.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Elision advances iterator (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-empty.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..053e0aaa495d1cbbc193a879a2503b38424b103c
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-empty.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var obj = {
+ async *method([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a85ce2a0f89614d1f2d4d208437885b8b8f4021
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e8057ec5b7abeb911f040b22d1eada0f642f808
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element containing an elision (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..adbc1a816fa86bdc884dbfb5043348a8fe902bb4
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..7c08905b89dacc19947037679bdd39053bc608bb
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element containing a rest element (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..90cbdc1e8a631484170569a17f34f2a39c7962e7
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element following elision elements (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var obj = {
+ async *method([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc88c7034c794d7db33c27200cf412cdfbdc4b6d
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..4382157cfdc2e11a1fe1f9c8262f72b13945b2d7
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-id.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Lone rest element (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var obj = {
+ async *method([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..14ec7d87263fe5ee1d6604cd962a8ced74efb6fc
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..fca362170d2ac71fb76ec1e2689e91a2a00e3adc
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-id.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...x = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..d873b1b04365a119a9cf3d0e3229582f88c2d2fe
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ x } = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ea655a09a1f623c418e1f42db1a08a7800ffa2c
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[x], y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6e5eb42650b9dfeea4b8e11146f0ce28a0f609a
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...x, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..e784923774d8f15ebc354549777735722ed6af4d
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ x }, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..baf63e81da1538e4c7b84cc67d46058f9a4278cb
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element containing an object binding pattern (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..e3601f3a8cd6feed6b311c30d5db6761228adddd
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest element containing an object binding pattern (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-init-iter-close.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..36a7165902e7fb209c6af1545e14db930ba423a2
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-init-iter-close.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..320a505ec2eae25d4230749fab794616e903d430
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-name-iter-val.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e345b4642885ba7c9c9f6486818564744ca95c1
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-name-iter-val.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fef251e24485e2caaf1a5fa25afdca069d650b5
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..2226c85a039704c0e344adc496e697d8bdf16622
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb460616f047e0ceae07c347479acabf36fee1b4
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d8633895dd740bee93dee5db6cde2539a895c92
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..45240896f51a9db9eb124fba8de9f21b003cc2c9
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+var obj = {
+ async *method([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..e739fc85c4bccd325100b7a367bd5332ef6032d9
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+var obj = {
+ async *method([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5e6071438265690fe4603acabb510902edb2907
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+var obj = {
+ async *method([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..75cb38cc855c71bbd7c791e04aa7fcd969d3d783
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+var obj = {
+ async *method([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..51a929aa06d8f977552346c59ad5673343d5e14d
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..edc0b478f84c0d18c871ac17e6df2cb53edd5a18
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..e09d4861b904e0c52dbe28e69cbf1d06a0ac4d48
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..9dca6381a21a5c30d32c4c610cd5e5a7a34e618e
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6d77ec9c16ab0cf7d3a974b7173df4358d495ee
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..da562222a68c4471877d48a01955a3a5cd13372b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..4513990768e26f3c650f23c8e78ee9d746b8ab47
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb2bb1d681c591bb8d4fc41a52e7b93b714f52c9
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var obj = {
+ async *method([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd6afc2d8838be2d91b8de6d48de7519e6abaf1e
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d15c16704c46c653d11449bf2071e3abb8f4442
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..1da266ae4191285016570c06457b736e1a3eba1a
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0f6ac8568cfbf4642ee26a233acedba2be88862
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbc61c154d50345333d2713e578835dd811dacec
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..3075aaef2dbbc8b328081b42cffe12d95a77d701
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ef45a2f7b7eb399d43fc2b0370c39ce6d747e01
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e11161d19f7c48c39fa7ef58de1da52f95f2d11
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..7afec8813c6ab7a4646ec3baf7ad1b166f3311eb
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Elision accepts exhausted iterator (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+var obj = {
+ async *method([,] = iter) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elision.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..e235d9fa986e8aae33297679578884601e55e852
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-elision.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Elision advances iterator (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-empty.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8e7ea1d3f2bb4d3f80596dd2084daf367ac32e5
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-empty.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var obj = {
+ async *method([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..19e83422db04b51831d96c97a9ed6f2b98f4115a
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..7646efd23fa53376742d2337dede8e26a3c189e8
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element containing an elision (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..e05934b2dd7368d80a2b758a6b51084325e1c1f6
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a74ce401053ae5fc28dcd4e33329268cd405f95
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element containing a rest element (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e9a7a297ea8742d04e32f5f760c619b42ad4e2f
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element following elision elements (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+var obj = {
+ async *method([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..8127901b63e93aa3e37df1b25d8bd317cf795b88
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5c1bb20909cb55c871e4377d3789380f8c7adac
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Lone rest element (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+var obj = {
+ async *method([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..f245f3cec95fee2fd00e9e48c80f0ce7b45b9cf4
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ba44f21294c3c43cff91c3df9e86d9905b63eaa
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...x = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a5405dc2d4d478363ff027c94759a0eadd915cf
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..11a6c7d4374c7837e55c7ad48ddb4b8c009c5368
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..e3d5d9bc3def46d12caac7f06e733731fcb1ff89
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..316274925dcd40049bf52a65d86991cc6c820bfe
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..0de62cb0df42c7849e926ec483b0a6e579774397
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee5540b8a003063844f96981bcd5b5dfa41259f3
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-empty.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..e00c5431bfd7f6799bdb15c2abce71aeaf0d232a
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-empty.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var obj = {
+ async *method({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..5134ef293070dccd94d7dc0e29aa0275a8d4b13b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1cff55fcba55ee7c417ed180a7237bda4572f33
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..db3a8fd631e2d7ee5b500d4552bf54a12ba45a7b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..e79109fd74ed1e5a5315c41259640bf512098921
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa376bd39d018152899787dbe9f82e776a2768ec
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc141617ea190213c0cdc63079675bde94065b20
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d7bc92d945337d00e224fb2f71b71f48fb579c0
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..99dc367f19cf15b0356dd4767e3f917060c145ab
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..b164875aca8a2cd0819c4c3336b6e105b14f188b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..13000678b892163e6cfbe7d675c14ae88b9c7ff9
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..813122d6edceb12f1f7e737cb288edc937435770
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var obj = {
+ async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..97facc2121b6afb9103ae5acec0a60a37cf85299
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..e0a6649411bb62997dc4cceb9284c47fc8527559
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..a19da6f05bd96426b520abb9cfa64aa3b3426a46
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Binding as specified via property name and identifier (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..310e8826a70d7030cca6afcc6fb4413008f314d0
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..abbf75114094a72fc9f6c11f6452d4fe366bc81c
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..bda58c0ca9453d938041b8d4809e0f432e278c51
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var obj = {
+ async *method({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a874c566eeb3b372928d7e7cfae50ce6116a6b8d
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var obj = {
+ async *method({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..e36d2567b4ae9b61b08e4dde101693cc22820aea
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb01cb6b5b48fc5908ef6abbdb3503dfac639baa
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..52dea8b3476ff3855075e5de5754c802f0e62aba
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var obj = {
+ async *method({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c2a19291fb2ced4e54630de67e23fcca365be32
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-method-dflt.template
+/*---
+description: Rest object contains just unextracted data (async generator method (default parameter))
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-empty.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..22dd65cc11d4959fef29e5517321506e3a2e48e1
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-empty.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+var obj = {
+ async *method({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..023538fa25a28406d6ee83cc56a68811ac1108c8
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a7500c0f3542deadd81a0c2eb1c86b0da72d532
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..d66b0cf9c93b4370c561908168662c39e96dd2d6
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2205817bdffcbd72bd519ebe8f63db83290bbb8
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..abb045b755be10ea1edc3bccc804964656246932
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..b23416a7963f47a13d600e7b6600dc5a5f989040
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..7cfb3d6d56bdab45c1f2f626f570eac22216cbf5
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d80a3dea952087c72188b74809fc4706923bc97
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..61d873955551a400e19e40d0545fd247ca46fccc
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..81f8e51f316d668c41a798b3c95cd1f52a446323
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-ary.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..6083b3e226124d872ba860a7fa2acf3d16a5c8db
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+var obj = {
+ async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-init.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..f33f24d56ebc1750193a41c84494652be6171ff3
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..6f6372ea4b79c0a0df4b0e91c61b1d64bd3f880b
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..813649196e266fdbc361d8f1007b81f3b5b8cebd
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-id.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Binding as specified via property name and identifier (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..decb9a913fd54f248c4afe484ae617bbcc764a4e
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-obj.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fea231d4fba55b40c3394f677e1459fdf0efc59
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-prop-obj.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-getter.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c1f1128ecb51807188424fb6d69870efe553402
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-getter.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+var obj = {
+ async *method({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d498eeccf7eb5d2dd955698d201d3ef2c8407f7
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+var obj = {
+ async *method({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..284e6c356af3d11f7d367396023f11d3aae59a66
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9509b285d0bc455bd3c5456dbb5989cdbe8f0fd
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+var obj = {
+ async *method({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..117de2a268897203926b8226903414e4f6253e84
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+var obj = {
+ async *method({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a1bf683075691719f538de47b19e6f1acc80488
--- /dev/null
+++ b/test/language/expressions/object/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-meth.template
+/*---
+description: Rest object contains just unextracted data (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+var obj = {
+ async *method({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+obj.method({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-init-iter-close.js b/test/language/statements/async-generator/dstr-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..90dfc65884a78d957576b4e7426ce88a20a5a817
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-init-iter-close.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+async function* f([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+};
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-init-iter-no-close.js b/test/language/statements/async-generator/dstr-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf71d05052034a50b139b45acd3340183be3b85f
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-init-iter-no-close.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+async function* f([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+};
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-name-iter-val.js b/test/language/statements/async-generator/dstr-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b0fb4a8f42a1de050f41b6f4e509b959f156593
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-name-iter-val.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elem-init.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e43ae848e59a75e49c6f78129cf535a0d34b886
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elem-iter.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..24f12c1e3ba52ed350d05baf09fe456aabaf08e2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+};
+f([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elision-init.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e3b4da7983b3605767099f100b119159d5e9dcb
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+async function* f([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elision-iter.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a151be92ce55256c9cd44f3b0b2cb668cca6275
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+async function* f([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+};
+f([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-empty-init.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..002e831708db023e53530387909c32ac8c397019
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+async function* f([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-empty-iter.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..afddd1c069fecaff8e7e2d8169be1a1ed452dd0d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+async function* f([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-rest-init.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ef9412dae2b9c2e7e9abebf16634a7173895377
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+async function* f([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-rest-iter.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..33055af22774227e0c7ff2afb65c566f42b7cf32
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+async function* f([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-exhausted.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba82ce74e1980e0c6f4995d2f250845b73d16e04
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..75f23a1017a67adb075c9ef9b50f165f18ef7563
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..db68e1028b8a8e39cf6d5a4eedf7544debcdc7e2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa5aa23d158f1fabc2f901adc44f02c7090368b3
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..1e6ed5c955552fa0689847b436b11d16c961367e
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba47c6da0126c7b3aaaac86903ee7dad2cb121de
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-hole.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..95c8e0a0ec9f6628ecdded272d515600792aee0c
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Destructuring initializer with a "hole" (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+};
+f([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-skipped.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b33450ab2ea81b4494d2a587259621d01033dd5
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+async function* f([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-undef.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf31ab915400cf3de2d94efd9d7e22141421f206
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Destructuring initializer with an undefined value (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+f([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-complete.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..39652e587bbebb17c3795d8e0ad5370b102de9b2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-done.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..09b6a7f4aa47cfffe6d15ed6f4fb7f649ea73d6f
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-val.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..379d181fcff969bf2c0280e8e9def1be3bc4571a
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-id-init.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..45bffcc9f4f9516452481630fb3e468c51a1a10a
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d53643e268292ff92a93aef3f365e9804b2c42b8
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+};
+f([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-prop-id-init.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..5584a570af8a854fd24551bc44c333f2ac0f872d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-prop-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f56359f7c440916f200aa0230dc8122ef16f367
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+f([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elision-exhausted.js b/test/language/statements/async-generator/dstr-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba34f1af90596af339127e973740839b0ba671d4
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Elision accepts exhausted iterator (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+async function* f([,]) {
+
+ callCount = callCount + 1;
+};
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-elision.js b/test/language/statements/async-generator/dstr-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..563736af2a05241cba248720255b80155ad7f24c
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-elision.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Elision advances iterator (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+async function* f([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+f(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-empty.js b/test/language/statements/async-generator/dstr-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..bca9a24a953521f24a3e3e4ab5c015c2e11f9c18
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-empty.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+async function* f([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+};
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-elem.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ec47c6a669c2088eba430578db9f8c5afce86fa
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+};
+f([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-elision.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..2599e4307fc02d5f0d374fd48e5d88525cecb042
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element containing an elision (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+async function* f([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+};
+f(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-empty.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..3383a05f8b27174037de092320df9993fa1b7ab2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+async function* f([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+};
+f(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-rest.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..87e1bb8994c5b3bc5b10db273e6b168cb6e64ab3
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element containing a rest element (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+async function* f([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+};
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-id-elision.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..76e3b66459a1482048ea0ef615ee4b46e7861b5e
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element following elision elements (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+async function* f([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-id-exhausted.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..eabf8f866c3ac0d2cba5e38084d6b5045d194e37
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+async function* f([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+};
+f([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb7d10bd0a6aa75819e5de74a37252b9d98ea3e2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-id.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Lone rest element (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+async function* f([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+f(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-ary.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7fb8ec102da58bd07a66aa946a2eeaa2c36398f
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..41a3a5c0f70aa619885cf9f1c49d8d61e70b60e3
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-id.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...x = []]) {
+
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-obj.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..81420e0b41f75d1cb0b9fda80d1fa8bc21756ca9
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ x } = []]) {
+
+ callCount = callCount + 1;
+};
+f([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-ary.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d9bcc79a258ad9c4bcf4e90ef0034dbefda1632
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...[x], y]) {
+
+ callCount = callCount + 1;
+};
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3ee45107b9527d3c4cdbe740f9e1fec10f44fb0
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...x, y]) {
+
+ callCount = callCount + 1;
+};
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-obj.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..1e5259c387119839c3de51743c310f12b157a3c7
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ x }, y]) {
+
+ callCount = callCount + 1;
+};
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-obj-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..47027b590dd31e8d5c864fc220a1a709dc3aa3a9
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element containing an object binding pattern (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+};
+f([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-ary-ptrn-rest-obj-prop-id.js b/test/language/statements/async-generator/dstr-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..01b3ef05d0b0cc2daeca91eabd0bcc80d218925d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest element containing an object binding pattern (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+};
+f([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-init-iter-close.js b/test/language/statements/async-generator/dstr-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..520e4a6106878452734008b2c10bd2454946ffa2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-init-iter-close.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+async function* f([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-init-iter-no-close.js b/test/language/statements/async-generator/dstr-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..f295723293baac55663ac1c799b4154bf38d894b
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+async function* f([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-name-iter-val.js b/test/language/statements/async-generator/dstr-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..09220556166297d513bd1d1875e74c03d95fe745
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-name-iter-val.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2a5ed3f1750c500653130d29c3b67110d390ffd
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..5bfb2622f876e5b899ce91cfb41e1c706c763ff4
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b65bf8b5b0684412ed836f8143f2929820d7100
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+async function* f([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..b854e0ecb920242a342a0fdbd8a368da55dac60d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+async function* f([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..2f7f07c61a9ce8aa4b889460fecbde023ce09699
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+async function* f([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..4aee4dbecf2d59396182cf6529b64fb8c871b7ee
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+async function* f([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..0abc885975ce84344e653c37566a81c3b100269b
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+async function* f([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..4538399d883f5957dcdb6704256bd98a74832a3f
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+async function* f([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd3febb82a072cd808a79449edd1c942dd7010d2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8e98b1576329799749d46458bebd655c34467c0
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce4fadfe119c88a9d39d5508d822a43d5095588a
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..0bb2d7fbd284db783eff22ef1de384fc777a2aac
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a83484322b840ab5623d78fc541639de66c5c58
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..54c2700c0be2937014c521d990a67757b8675b49
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..32767ca8c49787dc43bc8690dce2f2d44f3192c6
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..342518de2045e693ef654c021b95c89683b0da1d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+async function* f([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..087f3dee6100c83a7cf37301f744466a5f377dc9
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..76d8c3f9ae765825f2d584d71c2c25c1d9025a04
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..f1877389356c072ee26e8f5c8b7f0ce8ba733c17
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..d0a311731ee89d861c6ad1f008b8e6bda0cf248f
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..9fc3bdcde3059f79cacddf488b413db92f954ab8
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..6fde28292ba8ab4cd170a91d7e8a9ccc7f2a9ad6
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b0fb3dc8030c1cc820c37d0596d1487fa1bbfcc
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..10bec9e8d9726b2e2785dc16d6e355e41352327a
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+async function* f([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elision-exhausted.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..afdb017e339cabd9f6b4124b562984f7cb7f52e8
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Elision accepts exhausted iterator (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+async function* f([,] = iter) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elision.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e869d93df4c3474e437b17a2ba2d49df3c60b54
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-elision.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Elision advances iterator (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+async function* f([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-empty.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..d54c3a8c37135bebdb31eb19bde3f5aae8f8af45
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-empty.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+async function* f([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-elem.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..6777ce74eccee149af2e0426fe495c4661593c11
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-elision.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..05a65acb157e1d15e769caae0bcd40b55e40607d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element containing an elision (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+async function* f([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-empty.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..3b21184b0713d876c364fd867f87425286b34ea7
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+async function* f([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-rest.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..698d7107ac20f5f8505e59a56a480019e19ecfcc
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element containing a rest element (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+async function* f([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id-elision.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..959cd49dfe5cb88c75a3fd62e1ab2e9b9af59f52
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element following elision elements (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+async function* f([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..82fba931f185998218252e9b98fffffdc66d66b2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+async function* f([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7609570d3248e3a436628fc7b8b95c53372d1b5
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Lone rest element (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+async function* f([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-ary.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..487ac76dd34a38d1d1cb01b390d08712349850d2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..15198ec7e1632e9004d382efb1887aeceb4ec4b0
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...x = []] = []) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-obj.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..12b82a0bcfcd2327b7980fb857821f97aec094f1
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..373d090c0941a77b54e067c51159e6d5a101111b
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..81e7f260ffe473e13e8920263e79e32e99a14374
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..83bda6e96dbe440d3e73fb7d1b63e737fe94e7a0
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-obj-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d2d8339cdae113528c04ba74ff40750d6107a471
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..a5ffa82fc065d34106bdc35223c2c3d0c7839f77
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest element containing an object binding pattern (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+async function* f([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-empty.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e3164e764415d6d03297d38e805c85aea4dcfd3
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-empty.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+async function* f({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..255c726920415e2d1c634da82b77bb729813af94
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..3f80202a68fbd6203aaf503b245110f1e6ce1652
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..d26474659a35865b6f9e07d0d133f9c3fd9fd19b
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..0dae03fee65390b81f696df7fc8abf16fe397259
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..685bddecfa4f8f3d17e7acc8050318179a88d036
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-skipped.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..841f82081f65acda65ee6c7672944aaa22ced94b
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+async function* f({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-trailing-comma.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd0ef6b2d8feb26146355fe44ba842b67bb4e99c
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+async function* f({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary-init.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..bce18088d3a7b845f01656fb057b4be844166174
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..7aedec2da09d8532c5b5e7b99b3529c3c46f2b99
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+async function* f({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..b3d65792e3f7641c093cafe7c08dd61792be3034
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..d488d32ba46763e4bbfabdc74fbe1e17f4ba43c7
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+async function* f({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-init.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..82009c8d0f1a8c725f753954e8de314cac662607
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..f6bee2787bf7c320cf3ca9db46d1670b002986af
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+async function* f({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..b6f0ad17d190f14d9b18ae912bc2db26953d8de5
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Binding as specified via property name and identifier (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-obj-init.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..56bb921a504466ff9b97f492ca393e84aac652c2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-obj.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..1de9b79da09529ee47056491f5df3a5688cead91
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-getter.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..118c4dabf14cb7e91742a304a5a0c58eaa6d1a06
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+async function* f({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-nested-obj.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..dad25d8b5905f1ea29a2f980ed56b30cef302798
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+async function* f({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d14202a8fc093a1e3339ecf2973c084ee611fc2
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+async function* f({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..9126d241b4f1b898cc0d509df2ec8a8b029696c8
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,34 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+async function* f({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..b31494e1f0864e0ab81b99328ba57ac5f4734f12
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+async function* f({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-val-obj.js b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..1941e7c625c331e84e448f6e5e887ee5de05ac1e
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-func-decl-dflt.template
+/*---
+description: Rest object contains just unextracted data (async generator function declaration (default parameter))
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+async function* f({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+};
+f().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-empty.js b/test/language/statements/async-generator/dstr-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..1acac49c1d820162ea949dea5ce98ed69ef4c42d
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-empty.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+async function* f({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+};
+f(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-arrow.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ba29307facead78499dba506bd12802346bff59
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+};
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-class.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..606b3898407a903281cb1156f85e7c33f410dff8
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+};
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-cover.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..9eaec4f5666d95e9262b6b365b8f1f275d75141e
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+};
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-fn.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..be8b08c4c945d18952d46fe9dfd4b060a4b7a574
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+};
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-gen.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce0291beb81c938bfaf4d2cb5e03d0f2a0015215
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+async function* f({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+};
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-init-skipped.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..9dc2a56e429cfb1ceb90a19e9d0586866bfda963
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+async function* f({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+};
+f({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-id-trailing-comma.js b/test/language/statements/async-generator/dstr-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d52cd21cb7428b47448e199387de3b86126e1a4
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+async function* f({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+};
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary-init.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..03a6c1ddbe219eb98ff35275703caca61695b4be
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary-trailing-comma.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..b7fe733228fd6a41538edb16bc7f98551a837757
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+async function* f({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+};
+f({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea967b7086278832c4ef66be08eb916bd3843506
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-ary.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-init-skipped.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..e76966c182bbc4be360126bca60cea6961196908
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+async function* f({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+};
+f({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-init.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..00b23fe5a89d5de2021d8969e8033112357a9f6c
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-init.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+f({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-trailing-comma.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..dfdd7b72605ef6791694f025c6819d9d5b32e81c
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+async function* f({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-id.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e2c2944fbe02640b28241b9d8704175b1888441
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-id.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Binding as specified via property name and identifier (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+async function* f({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+};
+f({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-obj-init.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..65e6a7471a6c6729fc3678fded00e4e73a1a209e
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-prop-obj.js b/test/language/statements/async-generator/dstr-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a1f32e4e4d7d082855582a9a3a1ab9a1ac7eef78
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-prop-obj.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+async function* f({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+};
+f({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-rest-getter.js b/test/language/statements/async-generator/dstr-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..412edc4ff8ee4ebbfebf0a3b29fe98faf1098473
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-rest-getter.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+async function* f({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+};
+f({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-rest-nested-obj.js b/test/language/statements/async-generator/dstr-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a0d7ed2da5ae400423962b34db1b2515668e9176
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+async function* f({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+};
+f({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-rest-obj-nested-rest.js b/test/language/statements/async-generator/dstr-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..349abc7bd29fb4dbbd5dc6dcc8ddd175bc8594b5
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+async function* f({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+};
+f({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-rest-obj-own-property.js b/test/language/statements/async-generator/dstr-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..d272b6b87263f996218fc08311f250297e196ce5
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,34 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest object contains just soruce object's own properties (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+async function* f({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+};
+f(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-rest-skip-non-enumerable.js b/test/language/statements/async-generator/dstr-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..053aa0714ce2ff4827392380795d3e930eac3c22
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+async function* f({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+};
+f(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/dstr-obj-ptrn-rest-val-obj.js b/test/language/statements/async-generator/dstr-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd3c92eb346f1445aac2164c24381b452b547f8f
--- /dev/null
+++ b/test/language/statements/async-generator/dstr-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/async-gen-func-decl.template
+/*---
+description: Rest object contains just unextracted data (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+ ( FormalParameters ) { AsyncGeneratorBody }
+
+ [...]
+ 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody,
+ scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+async function* f({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+};
+f({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-init-iter-close.js b/test/language/statements/class/dstr-async-gen-meth-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..971d7aee311ba5644058f2d223a65e0e503f2c87
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-init-iter-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ async *method([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-init-iter-no-close.js b/test/language/statements/class/dstr-async-gen-meth-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..b099cd4e30c46c2f99d6b90f716b022bbccddb25
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-init-iter-no-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ async *method([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-name-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..65f44000a61be0e29bae37aa7d5ed4de3d89fc80
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-name-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding with normal value iteration (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..90710d35b04fef7a219d209b47353580ddc32f88
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..e43c7ab9d507c7e8aec56d23b0e2323428e848e6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([[7, 8, 9]]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e590b213df7612fa7473316ee7f184ba1b6b849
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c5f8a5f3c644914f04e133e3afe7b61de5beb05
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([[]]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..74a2c48c28d7e3f1d8a7addf54e385b67e8ce421
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+class C {
+ async *method([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd71d0ff494d8e552b22cfc366e520ee2c6142d0
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ async *method([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([[23]]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..71da1f63094409ac32ffbd470e33517800d0dc22
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+class C {
+ async *method([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cf6cb7d329fe49dd016496c59ffad06899da162
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ async *method([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([values]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..39626746dd4bb3d510f37024653b0cfbbbdf1e85
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Destructuring initializer with an exhausted iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..b1b6c2257e7cf16876ab13f6c1394a22ffc3aa80
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..b23ac691583235a0c8e9440f0732836890fca953
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f1a264b5abd01c35acd287eea370ec089ab7c0f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..353bddb748e2d5773b099bc4daf4a2665edbd57b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ebe7abf1fee0ed0689a1f232292764897228cd8
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc89627807c6e5f78a46e8c0b8da2118a5a7bb50
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Destructuring initializer with a "hole" (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([,]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..3cfd54f449c917614b3655bddec5ebabd29b29bd
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ async *method([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([null, 0, false, '']).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6d233632d07890278db4f8c0cc6f84efb2aebcb
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Destructuring initializer with an undefined value (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([undefined]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a42d3ca48c37829d971cd04f43047bc09259d44
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration completes (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fdc18e597afa876a70c4f1777b13613314aaaf5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..e0cdddb5a28f3a3f4773d413fd128a6920eae35b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..29957f1613b50abc295d0cb626b7286cc6052636
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..c9953ba55c5dc9df16350577937bcc271b820be6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([{ x: 11, y: 22, z: 33 }]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..747a5b48cc14b9b6ac8c0a10bc64448a9bee2ae8
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..014fd4a05f97482ff8eb28f06a66c72b5180eec7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([{ u: 777, w: 888, y: 999 }]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..e91832bf42039f242ee2c01295a558df1de220fe
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Elision accepts exhausted iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+class C {
+ async *method([,]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elision.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..28f21340028e96f003a64e909516911fbfaf6b85
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-elision.js
@@ -0,0 +1,82 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Elision advances iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(g()).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..993be0402e19c050445f62af16d8f8abc442b9f6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-empty.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ async *method([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..0a2299455be73a7fb0130a60c5fc6b73bb244d3c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,89 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element containing an array BindingElementList pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([3, 4, 5]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..624f98e60ce64ef1ab523fde78a09947fe4860e5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,95 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element containing an elision (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(g()).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..26ecac88d8756d1ddde56b625ad4e31993f9cc13
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element containing an "empty" array pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ async *method([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(iter).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fac70ab1f7c6f2b45bc45bf24342a049f94b86e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element containing a rest element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ async *method([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(values).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa2846b3db7a80dbc7bffe62ff8464c7ced2dc31
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element following elision elements (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+class C {
+ async *method([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(values).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7a15b6e1c22908633090d2504cdb46e0ad570d1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: RestElement applied to an exhausted iterator (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..668383f24804da028f001c6e94576b52939f5650
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Lone rest element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ async *method([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(values).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..288251a04e4d59c693458ddf8464d92230d87b59
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b2ead8567fd0a0b7fde7e7c465ee4c1c36fbe6f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Reset element (identifier) does not support initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...x = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..ada13130e2565ed5619d548e140b481b015b4063
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ x } = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..ebbe0da0b8551186c0dcb6e6f23de9160a9d2bbb
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...[x], y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..57a60181c111bcd3e3927736363139b8c4d25f27
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element (identifier) may not be followed by any element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...x, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c70accd822d12eee927b287c275a9cdaa4c0ac2
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ x }, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..ecb66df2b967acfb6bdfb10946b8cbf9add1482e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element containing an object binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([1, 2, 3]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e0779d5d44f8ee2ae6ae38be27266efeead9d95
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest element containing an object binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method([7, 8, 9]).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-init-iter-close.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..509297472c3d0d8cd6da48d45fd2124f89c83148
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-init-iter-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..165739e0173be7f3bbe5dcb16950e0e6fe7c82bb
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-name-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..f831f4b754afcf083e7e30cb0c5d7f7a70a529f0
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-name-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..7f1de2ac6d9c6124fc9f8d4f9b58a9d228520cc1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ce5771d2c18e9c63df4930176aa6aed7874b17d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..2570c05f6e7d167f907d6bf7937afb1f5db75c1e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c3a20d90cff4ee3f9c4dedc27e42ff8d32f11d7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..d715a340088b4cd54f016f85d441ba4cdda9da92
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+class C {
+ async *method([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..c062013c51a7f5469f4ad1f370ba86d46e389eb5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ async *method([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..172e4bcb0f84d4aae16bcee5acd4b8b7af0b8a0c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+class C {
+ async *method([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..09454924b48d64bd633c80d3f8b71d3ee41417f3
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ async *method([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..276ea236f1c4b2ba70d49ce5c69ff2c53362cc0e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..55def785f2eb80436e1934ece2779ff23a042a87
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea499bd48d48f9ab11305089004f385e673c77c7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..1122d40ee0da2ee32c58d3dab86ff76b4b87b4b5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..5dc7f84d956b2dafe045102c31a7a6bddd9973d9
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..c17a22987490799b14806b6a7c541ca8f885544a
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..48c868117241a150df42d924f3c6821921912290
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..00ec84a141d3f70649ebe5d8ca6795d83f16df99
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ async *method([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..517f08d4d5aa13af2b6215f6c3c40e8f3cb3a4a6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..cea4d69164f32e6024e9bebe5d3c9ecddf7f99b3
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6ed2eda4fdd0e09944e023690bb7a6c79b78479
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..c10f5272636fa8e73f0906a1b77189e3e63edbd6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..96b8384100fb8accde320cdd20f3b90cb15336e1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..440899c9674306cd6a66ac0a02eec580ba063b9b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6bd7cf27598b6ae684eae8b466250e239de0940c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc8c8a700ad258ba534740f13518838a166db6d4
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cb23e5ee9b681c6f0b0b8fe20e090815b55ed0c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Elision accepts exhausted iterator (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+class C {
+ async *method([,] = iter) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elision.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..5739c3934f27951984ca6775cfb0ddbf17314e61
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-elision.js
@@ -0,0 +1,82 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Elision advances iterator (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..0508d7e055a562ff0f2a28f975e598f88afa2700
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-empty.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ async *method([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..06b68ca01812d8d3b85b0e4bb542f8af7d5999c1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,89 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..07d07bde9b5287fbf45a344b48331d42183f24f5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,95 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an elision (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ async *method([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..932cf50322a99912b7cf30e3cb6b8aabd22b64aa
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ async *method([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..0806d0dc7e6065fadea6b2684549be0f7a32de70
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element containing a rest element (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ async *method([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..b10b1010677f16ada675f3e1ba512ff99951f272
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element following elision elements (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+class C {
+ async *method([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2a1fda28450438b12c773fbd9a4b545c597bf8f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..513261a5dc040f6f85a6c2bde2df0f052c3b0a97
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Lone rest element (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ async *method([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ec56766115710c34d86dcf331bc2c4ea2dccbc9
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2647de0198de1464564a7f43465ca38832401e05
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...x = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..9fd3f7c49cbf76873189470503e5dc20e0556347
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..00031c00cb4a25808b48a58a15eacfe7f1408441
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..519ac4b21bda24e7462494138a04b8d451f57941
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..2056407da66bf5851b6db63413ec97d003f5d8a7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..505e99c99c87394863d77bd6daa0e2354674ebb2
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an object binding pattern (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab09cc65603b17700340812529e945d51728e8fb
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest element containing an object binding pattern (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..17cbc4607d07116b2176215b5db4d936908f0f95
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+class C {
+ async *method({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea04fe7261375aa1b770d036c6f0c7233ec3e98f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..f591d5e3dc59a7076862e718d1c639f302c5fe9d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..705fc87c649d1ff8eb3bb6eb744c0f5fc15fb70a
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..b953503f1bcd61ac91c77a407c87def1b3817086
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..2fa14d8077d7ee5987db7681354c323df8a00421
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa26f479bfe5d4f15cd51a009c13e50c6fed5316
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ async *method({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..0dde36800f7c816a13053e4b8faf771fc0b6eb0d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..19fc663504500f1cc44499e8dd4840002ad9875d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..da474893cce1666e74b1a130df8bf2cafad3e75c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..30f0939992021129c1151a19cac3519fb8a5cd49
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..0a65da7d85645033a253504ac652503c9e859d28
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd7f4326402ff35b2e08c90931eb29aca6e51c61
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..1469a69bb32541bc2a13970c57549ec618af2009
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..30e06ce756ee3d023ec742401c2f4455480625e7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Binding as specified via property name and identifier (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..a00c5f409a618f763d144f12cb611046714cef64
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..d63d4dd5e74abab1dbfa62f8b4839a530cb5db4f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..231e8cc8a63c54a15e1a5dc7459d05c8aa36e0ac
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+class C {
+ async *method({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..c883e41aad5317c96eec29f95a23d58fd55a0dff
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+class C {
+ async *method({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..b920ff4d9f164f9327e3cd5d0c69a4552bd4ea16
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..26bda7d25266068290a5bc9d2e1d32c153c6a9e1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+class C {
+ async *method({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..eee29c151ce7c718d388c7820f082df20f322dbc
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+class C {
+ async *method({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a99f649b59911f58eac5e3cd9ccc1211a66dd138
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-dflt.template
+/*---
+description: Rest object contains just unextracted data (class expression async generator method (default parameters))
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..05b485944d9e8ac23ded87e895dad126b2be53eb
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+class C {
+ async *method({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(obj).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..ecb36a6e9540bf89a8a50143f6aa83b5c08a3206
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..21d622f78c2d5740955b490cd11843503febc71a
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c1b3136e7d9fbf88a0e977088dfd33fd1c6a0c0
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e63efb390f5510510f5bb4155bfe539a2dab83b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e1ff458f522359bac23b1a79414b5b6b62eecf7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..e4dc36c030354d03cda4055e7e8e728ffb41e5a5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ async *method({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: null, x: 0, y: false, z: '' }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..3be34ff8e311f5c032b00c3855c6fd6d5fca8e17
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: 23 }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb6710d4e653b333bb9af9fc60df15fd2f516f57
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..5dd59556008fae1c070bf9fad1f413f867628b58
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: [45] }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9817a218689119b00105588c44c6b76b41a1f10
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-ary.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: [7, undefined, ] }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..3fbca41b593fdd06d1df0e46b0b92c27b0eff841
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ s: null, u: 0, w: false, y: '' }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b0eb74b221b2cdc58671f3548ef84de2bf7f4e3
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-init.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..5627827c5234a4f8073dc70b6fce9a6099ecb93d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: 23 }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..563e2fd702c67de9a90e751d8c5f66526fd616cb
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Binding as specified via property name and identifier (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ x: 23 }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc6875ba176b719fa48a2d2e5a89c50259d9ea7c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: undefined }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-obj.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f1e0114b0d62af4a0038cbb9a637fee9236dff2
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-prop-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ w: { x: undefined, z: 7 } }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-getter.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..2727252e4db625181e0029578694efb7ad923487
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-getter.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+class C {
+ async *method({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({ get v() { count++; return 2; } }).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..27bdd8a09ef6dc960076c15a2756bd0109c6ac62
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+class C {
+ async *method({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({a: 1, b: 2, c: 3, d: 4, e: 5}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..4cd1594eb09f94cf9db6261e120903571703f335
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({a: 1, b: 2, c: 3, d: 4, e: 5}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..8763dae8229d85d3161322c4dd85eca55142c300
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest object contains just soruce object's own properties (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+class C {
+ async *method({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(o).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..80ba9c2b199de6ea1ada06c362e0abb1903cd0c8
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+class C {
+ async *method({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method(o).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..f4586e45369cc61db6c3c5e172867bd9b3ab0e87
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth.template
+/*---
+description: Rest object contains just unextracted data (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ i. Let status be the result of performing
+ PropertyDefinitionEvaluation for m with arguments proto and
+ false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ async *method({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+new C().method({x: 1, y: 2, a: 5, b: 3}).then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-init-iter-close.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..0acabede3c621c6d5cd33c05aa0ed913a8ef21be
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-init-iter-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([x]) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-init-iter-no-close.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..434c1ea3a9d33c709372fd69395a630fd74c8537
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-init-iter-no-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([x]) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-name-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..9bb3af7f671beb0fbb8c823d7112034d36dea9ed
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-name-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding with normal value iteration (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-init.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..96f3525a9be45afeeadf1fe0c4bec108a5d67811
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ca4813a94fb77c32dc07f1295a69eeb8d833529
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([[x, y, z] = [4, 5, 6]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([[7, 8, 9]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-init.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..247933d9e887dc2ea3525ae8862c0e3108c88d9a
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([[,] = g()]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..dbbdf046a59c0774abb349dc2d2c4b6fd439cb09
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([[,] = g()]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([[]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-init.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ecf68c3fa3a807d5ec7dc71fbd2faa88c7ef682
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+class C {
+ static async *method([[] = function() { initCount += 1; return iter; }()]) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..6562516ccb65b005ada9f91ea3b591c2ae9ffa06
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ static async *method([[] = function() { initCount += 1; }()]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([[23]]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-init.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf7a479631c116b762222af0b251c88752af7d6d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+class C {
+ static async *method([[...x] = values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..0713b6f13fa4ed2cd32e0402558d902894a091c9
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ static async *method([[...x] = function() { initCount += 1; }()]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([values]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..4260c271d0f05b6b792587c0fef5431efe308863
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Destructuring initializer with an exhausted iterator (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..40ccaff0a49d555798b1ae6d814668d71874e51d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([arrow = () => {}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..53996d1325eb0af3f3d625d6b2e12e87f3468367
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }]) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..9560c161bc38b581161673bc0789ccd85173e306
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([cover = (function () {}), xCover = (0, function() {})]) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..e16f6bf9bcc56cc0f19dd9741091ad60e5155ab7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([fn = function () {}, xFn = function x() {}]) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..077f273e0071bcba7c602f7020530c77dd59a3d9
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([gen = function* () {}, xGen = function* x() {}]) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-hole.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..299d12d74d226c3f905b8340b36cfdd02e7c8688
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Destructuring initializer with a "hole" (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+C.method([,]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..04d98961938ea5ce8c076fa4d26c43736f83a055
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ static async *method([w = counter(), x = counter(), y = counter(), z = counter()]) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([null, 0, false, '']).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-undef.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ab5aa22ee7d425c4cca58de67b3f856308854f6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Destructuring initializer with an undefined value (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x = 23]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([undefined]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-complete.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..759d5f8a96eba75b555a63f10b08cf69341c5575
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding when value iteration completes (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-done.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3b97222ba9e6aac95f5f5bedbb2e9a74fb5959d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([_, x]) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..7fcbe12cccbe007780753d7ee24117430992b8e2
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x, y, z]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id-init.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c931e8ef95a3e00e7a6e7ad5ba7fd585cb0c35c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..5287ef34fb71bbb0f09658c00b92ca700b8cf33c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([{ x: 11, y: 22, z: 33 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..b8ba6076897b8ea096cdff3808ba9b9275616e71
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..448b98c7f66c26462027deda0c0c6a572c499b93
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method([{ u: 777, w: 888, y: 999 }]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elision-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a1a7c44dd758d38a69c01c986140c87df10bb7e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Elision accepts exhausted iterator (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+class C {
+ static async *method([,]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elision.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..3c774aaec47e8895c814dd57ada981f0fb4ac27d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-elision.js
@@ -0,0 +1,82 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Elision advances iterator (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([,]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce4c617821397e704c41d446c912341589f39c36
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-empty.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ static async *method([]) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elem.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0c4ed63893d02e16a14e20310d6bd7412b3f2e3
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,89 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element containing an array BindingElementList pattern (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...[x, y, z]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([3, 4, 5]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elision.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..0ed9b9699361e89450c08c0f1e67d262a8686c9b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,95 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element containing an elision (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([...[,]]) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(g()).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-empty.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..82db405ca12f0b4d88b25c2c2e696fdc13dc18ee
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element containing an "empty" array pattern (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ static async *method([...[]]) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(iter).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-rest.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc9f6964630755658fcbe80f2b53e8f79d3922dc
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element containing a rest element (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ static async *method([...[...x]]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-elision.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4453921c3b4ba9c795ae2e9067ad6b4a70d05ee
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element following elision elements (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+class C {
+ static async *method([ , , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..68808fda456f364ded0fb9923a5b9645efe2eb63
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: RestElement applied to an exhausted iterator (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([, , ...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..d032debdc3ca65687e46011bbb4ad2da802d791d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Lone rest element (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ static async *method([...x]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(values).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-ary.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..8428f3847ae26f145ce0ddd57bff85c0ab76485f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...[ x ] = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a85bed753370373bd14929106de3d13818b0d3b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Reset element (identifier) does not support initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...x = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..7c9005089fe567d04c0d5d5034417b1c7c4166f0
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ x } = []]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-ary.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..a648ca0609de80ac448727e7969db7ed1e6cef0c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...[x], y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..1591d14f38c97f6a31dc8ade65d1bb1c932ad664
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element (identifier) may not be followed by any element (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...x, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..c864ce2bf58a1778b73044b7ac5e558f61bb760c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ x }, y]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ca10c23e0eb7f458ee5889d8af313f021c98fdc
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ length }]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method([1, 2, 3]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5cfc7f23e41a26d940a318168a997705fd6588c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method([7, 8, 9]).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-init-iter-close.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-init-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d4a3139140c36405ae3ec5e8ae4c08510553b0e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-init-iter-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Iterator is closed when not exhausted by pattern evaluation (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: false };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-init-iter-no-close.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-init-iter-no-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..7372ecd8a97c5947898a19fe78fd23c0fd732b2e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-init-iter-no-close.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-init-iter-no-close.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Iterator is not closed when exhausted by pattern evaluation (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.5 Runtime Semantics: BindingInitialization
+
+ BindingPattern : ArrayBindingPattern
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, return ? IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var doneCallCount = 0;
+var iter = {};
+iter[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: null, done: true };
+ },
+ return: function() {
+ doneCallCount += 1;
+ return {};
+ }
+ };
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([x] = iter) {
+ assert.sameValue(doneCallCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-name-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-name-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9fc253e012e0609f8008a3e506b48dc3c6425ed
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-name-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-name-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding with normal value iteration (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6247204155eccc5555cbbf3a182bb466236614b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([[x, y, z] = [4, 5, 6]] = []) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..dedf0a4da237de744bde0403351fed3856b3a7d3
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elem-iter.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elem-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([[x, y, z] = [4, 5, 6]] = [[7, 8, 9]]) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, 8);
+ assert.sameValue(z, 9);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..fbd603859c81f16d1cb08ad2c0cbd41a9c1a306c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-init.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([[,] = g()] = []) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d457b9c0f3f2edbee191d1aa47819636633fb8f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-elision-iter.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-elision-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+
+---*/
+var callCount = 0;
+function* g() {
+ callCount += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([[,] = g()] = [[]]) {
+ assert.sameValue(callCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..0498324292723de732bb11770b96e599c4089510
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+var iterCount = 0;
+var iter = function*() { iterCount += 1; }();
+
+
+var callCount = 0;
+class C {
+ static async *method([[] = function() { initCount += 1; return iter; }()] = []) {
+ assert.sameValue(initCount, 1);
+ assert.sameValue(iterCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..66b50ef55fdcb8be62f8d4fb3b56527dd760e8d7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-empty-iter.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-empty-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ static async *method([[] = function() { initCount += 1; }()] = [[23]]) {
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f5d744682ad1003d5346f733073294f8fd4ec74
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-init.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+
+
+var callCount = 0;
+class C {
+ static async *method([[...x] = values] = []) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
new file mode 100644
index 0000000000000000000000000000000000000000..5da5b537183997e907ac0d5624f340c49d22319e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-ary-rest-iter.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-ary-rest-iter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with array binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ [...]
+ e. Else,
+ i. Let v be IteratorValue(next).
+ [...]
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+var values = [2, 1, 3];
+var initCount = 0;
+
+
+var callCount = 0;
+class C {
+ static async *method([[...x] = function() { initCount += 1; }()] = [values]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 1);
+ assert.sameValue(x[2], 3);
+ assert.sameValue(x.length, 3);
+ assert.notSameValue(x, values);
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..12d825379b1b6525b1cfc267b56e1b216deaecf7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-exhausted.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer with an exhausted iterator (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x = 23] = []) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..88d780d96765bea306ba7ba8ef27397ede2e49e1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-arrow.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding does assign name to arrow functions (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([arrow = () => {}] = []) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d59ccbc89d6e79c6d91f4b1e784e418c407e441
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-class.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([cls = class {}, xCls = class X {}, xCls2 = class { static name() {} }] = []) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b24acd36a10d74bb4dd15f489c09462f84e3212
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-cover.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding does assign name to "anonymous" functions "through" cover grammar (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([cover = (function () {}), xCover = (0, function() {})] = []) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..68c8a14ae6f22d820aa22a65d9304b91640acfb3
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-fn.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([fn = function () {}, xFn = function x() {}] = []) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2db9b5fa5682bf975b41bb00890d96f5b1bdd73
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-fn-name-gen.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([gen = function* () {}, xGen = function* x() {}] = []) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba106fa33a30aaf74037b1495295c11efe25a82f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-hole.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-hole.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer with a "hole" (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ SingleNameBinding : BindingIdentifier Initializeropt
+ [...] 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v). 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x = 23] = [,]) {
+ assert.sameValue(x, 23);
+ // another statement
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..9fcf825bc6ee74fd80cd99d083232ab99571393d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-skipped.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ static async *method([w = counter(), x = counter(), y = counter(), z = counter()] = [null, 0, false, '']) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..66ddcf0473e05b0c5c73d48d2e6fb2dcbcdc133c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-init-undef.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-init-undef.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer with an undefined value (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ [...]
+ 7. If environment is undefined, return PutValue(lhs, v).
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x = 23] = [undefined]) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
new file mode 100644
index 0000000000000000000000000000000000000000..520436ad04cf0c07d9867ac327c0d4dd7f244dfd
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-complete.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-complete.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding when value iteration completes (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
new file mode 100644
index 0000000000000000000000000000000000000000..98bb986297d7f6cee420310e293954d9bc0bb2a0
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-done.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-done.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ [...]
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([_, x] = []) {
+ assert.sameValue(x, undefined);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..786f031455382a74cbb62ae30251735805c5ff0f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-id-iter-val.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-id-iter-val.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding when value iteration was completed previously (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([x, y, z] = [1, 2, 3]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..12b5b5d0b2432356baf38cfb694f7420537cd63e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id-init.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = []) {
+ assert.sameValue(x, 44);
+ assert.sameValue(y, 55);
+ assert.sameValue(z, 66);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..c5b4fa4d9fdc28bffdc2ffdb41d1452927a4fd27
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-id.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ x, y, z } = { x: 44, y: 55, z: 66 }] = [{ x: 11, y: 22, z: 33 }]) {
+ assert.sameValue(x, 11);
+ assert.sameValue(y, 22);
+ assert.sameValue(z, 33);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e0239c9f5ef816e5baa2ee50cbdda4263a71129
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id-init.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = []) {
+ assert.sameValue(v, 444);
+ assert.sameValue(x, 555);
+ assert.sameValue(z, 666);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..fed7135c442204510846bb7b0939cbc99bba2036
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elem-obj-prop-id.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elem-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: BindingElement with object binding pattern and initializer is not used (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingElement : BindingPatternInitializer opt
+
+ [...]
+ 2. If iteratorRecord.[[done]] is true, let v be undefined.
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be ? GetValue(defaultValue).
+ 4. Return the result of performing BindingInitialization of BindingPattern
+ with v and environment as the arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([{ u: v, w: x, y: z } = { u: 444, w: 555, y: 666 }] = [{ u: 777, w: 888, y: 999 }]) {
+ assert.sameValue(v, 777);
+ assert.sameValue(x, 888);
+ assert.sameValue(z, 999);
+
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..9cae8854d20ee0190d86c748928aaf8d12726b7e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision-exhausted.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Elision accepts exhausted iterator (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ [...]
+ 2. Return NormalCompletion(empty).
+
+---*/
+var iter = function*() {}();
+iter.next();
+
+
+var callCount = 0;
+class C {
+ static async *method([,] = iter) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc16bba9384867492829cf593352416f083de3ab
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-elision.js
@@ -0,0 +1,82 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Elision advances iterator (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([,] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..234218c13efa3716ebe3fc7666a50760abb00179
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-empty.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: No iteration occurs for an "empty" array binding pattern (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ static async *method([] = iter) {
+ assert.sameValue(iterations, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
new file mode 100644
index 0000000000000000000000000000000000000000..d78a806b1017d6b2d0f5aec256e3fef943220997
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elem.js
@@ -0,0 +1,89 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elem.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an array BindingElementList pattern (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 4. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ e. Else,
+ [...]
+ i. Let v be IteratorValue(next).
+ ii. If v is an abrupt completion, set
+ iteratorRecord.[[done]] to true.
+ iii. ReturnIfAbrupt(v).
+ 5. If iteratorRecord.[[done]] is true, let v be undefined.
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...[x, y, z]] = [3, 4, 5]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y, 4);
+ assert.sameValue(z, 5);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a0f14f21f834ef07af7f2ec7947d647efa6c4b8
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-elision.js
@@ -0,0 +1,95 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an elision (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ Elision ]
+
+ 1. Return the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord
+ as the argument.
+
+ 12.14.5.3 Runtime Semantics: IteratorDestructuringAssignmentEvaluation
+
+ Elision : ,
+
+ 1. If iteratorRecord.[[done]] is false, then
+ a. Let next be IteratorStep(iteratorRecord.[[iterator]]).
+ b. If next is an abrupt completion, set iteratorRecord.[[done]] to true.
+ c. ReturnIfAbrupt(next).
+ d. If next is false, set iteratorRecord.[[done]] to true.
+ 2. Return NormalCompletion(empty).
+
+---*/
+var first = 0;
+var second = 0;
+function* g() {
+ first += 1;
+ yield;
+ second += 1;
+};
+
+
+var callCount = 0;
+class C {
+ static async *method([...[,]] = g()) {
+ assert.sameValue(first, 1);
+ assert.sameValue(second, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..32928908252bedebf83b5132912bbf14bc13ca9e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-empty.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an "empty" array pattern (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [generators, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ ArrayBindingPattern : [ ]
+
+ 1. Return NormalCompletion(empty).
+
+---*/
+var iterations = 0;
+var iter = function*() {
+ iterations += 1;
+}();
+
+
+var callCount = 0;
+class C {
+ static async *method([...[]] = iter) {
+ assert.sameValue(iterations, 1);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5e81a3bc92448a97e18cd64dbf7b6912017190c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-ary-rest.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-ary-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing a rest element (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ static async *method([...[...x]] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0026032379340cfa42b67e66fb5c07fbf7cc142
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-elision.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-elision.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element following elision elements (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ ArrayBindingPattern : [ Elisionopt BindingRestElement ]
+ 1. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. ReturnIfAbrupt(status).
+ 2. Return the result of performing IteratorBindingInitialization for
+ BindingRestElement with iteratorRecord and environment as arguments.
+---*/
+var values = [1, 2, 3, 4, 5];
+
+
+var callCount = 0;
+class C {
+ static async *method([ , , ...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 3);
+ assert.sameValue(x[1], 4);
+ assert.sameValue(x[2], 5);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b9402782c0637147844c3da077386226788e004
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id-exhausted.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id-exhausted.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: RestElement applied to an exhausted iterator (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [Symbol.iterator, async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ 1. Let lhs be ResolveBinding(StringValue of BindingIdentifier,
+ environment).
+ 2. ReturnIfAbrupt(lhs). 3. Let A be ArrayCreate(0). 4. Let n=0. 5. Repeat,
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. If environment is undefined, return PutValue(lhs, A).
+ ii. Return InitializeReferencedBinding(lhs, A).
+
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([, , ...x] = [1, 2]) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc7a29b57620a579cd59c36b01e93bbb38bf7480
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Lone rest element (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+ BindingRestElement : ... BindingIdentifier
+ [...] 3. Let A be ArrayCreate(0). [...] 5. Repeat
+ [...]
+ f. Let status be CreateDataProperty(A, ToString (n), nextValue).
+ [...]
+---*/
+var values = [1, 2, 3];
+
+
+var callCount = 0;
+class C {
+ static async *method([...x] = values) {
+ assert(Array.isArray(x));
+ assert.sameValue(x.length, 3);
+ assert.sameValue(x[0], 1);
+ assert.sameValue(x[1], 2);
+ assert.sameValue(x[2], 3);
+ assert.notSameValue(x, values);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..3cd5500f242a85aa452f72821b3dcc7755d8bef9
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Reset element (nested array pattern) does not support initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...[ x ] = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..df5515ce9920922ba020177798649b236aa656f2
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Reset element (identifier) does not support initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...x = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab907fa9e5b6b2e4000f0fbdfd6913e26623061f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-init-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-init-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Reset element (nested object pattern) does not support initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ x } = []] = []) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..7f49eea2ee987b550f34974f60560fda578213f4
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-ary.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element (array binding pattern) may not be followed by any element (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...[x], y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c5cef52d6fda46d94ce3f7cc9c492fb71549336
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-id.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element (identifier) may not be followed by any element (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...x, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..99ab54282d19932f97aa4374476ad457e4151136
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-not-final-obj.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-not-final-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element (object binding pattern) may not be followed by any element (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+ ArrayBindingPattern[Yield] :
+ [ Elisionopt BindingRestElement[?Yield]opt ]
+ [ BindingElementList[?Yield] ]
+ [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ x }, y] = [1, 2, 3]) {
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc3d08701b38b7c744ff29ee5b811c696a82e272
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-id.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ length }] = [1, 2, 3]) {
+ assert.sameValue(length, 3);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..eca28ce5b2161c7e50395faa830b116572446d3b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-ary-ptrn-rest-obj-prop-id.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/ary-ptrn-rest-obj-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest element containing an object binding pattern (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.6 Runtime Semantics: IteratorBindingInitialization
+
+ BindingRestElement : ... BindingPattern
+
+ 1. Let A be ArrayCreate(0).
+ [...]
+ 3. Repeat
+ [...]
+ b. If iteratorRecord.[[done]] is true, then
+ i. Return the result of performing BindingInitialization of
+ BindingPattern with A and environment as the arguments.
+ [...]
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method([...{ 0: v, 1: w, 2: x, 3: y, length: z }] = [7, 8, 9]) {
+ assert.sameValue(v, 7);
+ assert.sameValue(w, 8);
+ assert.sameValue(x, 9);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ assert.throws(ReferenceError, function() {
+ length;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..943ef404d0199746f0c52af4ac8091cba861a542
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+class C {
+ static async *method({} = obj) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..403d5d0aa59169d901ee52756cc8c5bec7e19149
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ arrow = () => {} } = {}) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..856417cd524a3a6fa0cdbe6ad69731ec49ff5290
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } } = {}) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd5cfddd9292ad5123f5869006c2d0dca0b0413b
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ cover = (function () {}), xCover = (0, function() {}) } = {}) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..0c72542f5ff766d3d3488dcfe393e620b692e307
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ fn = function () {}, xFn = function x() {} } = {}) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..604fe5e0b4cfbbcddd4be89b8ea2c27c7814fb17
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ gen = function* () {}, xGen = function* x() {} } = {}) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..c2dfc5d5ec26eca6c13ee969e95b649a03a1817c
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ static async *method({ w = counter(), x = counter(), y = counter(), z = counter() } = { w: null, x: 0, y: false, z: '' }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..43ee3792ac08873204cd6dee96769f4e2855ec23
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x, } = { x: 23 }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac8a21613b791b04f998fca281b43323ec663795
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: [x, y, z] = [4, 5, 6] } = {}) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a82f86707b9896d43d8a0a71287db8677d6cef2
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: [y], } = { x: [45] }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..199d28273bdb0eceedfe041a69b2f14d0a71b8e8
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-ary.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: [x, y, z] = [4, 5, 6] } = { w: [7, undefined, ] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..6153975a0981737a537c2d4d5224c62a117a15d0
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ static async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() } = { s: null, u: 0, w: false, y: '' }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a5667cd26778335243761b79c0118cfc3893f4d
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-init.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: y = 33 } = { }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..0275c810fa65a695fbdc0c75cd9a6672e9fe2f42
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: y, } = { x: 23 }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..e67b4e4027175bc8b004e4df26a13b14f751ba13
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Binding as specified via property name and identifier (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: y } = { x: 23 }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3c435260991f322d401cf0da43c137d5f8d6934
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: undefined }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d0c1aeddceb5bda2027bde5ede93f3ddec5473a
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-prop-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } } = { w: { x: undefined, z: 7 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-getter.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..ffac67afe4863a21766179463f61e8fb142a2ec7
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-getter.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+class C {
+ static async *method({...x} = { get v() { count++; return 2; } }) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-nested-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b69e00b2fbca0bedb20b23cfacecd1a61aad56e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+class C {
+ static async *method({a, b, ...{c, e}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-nested-rest.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..4871e43f333e4a3b0407ac313137b28fc7cd7676
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({a, b, ...{c, ...rest}} = {a: 1, b: 2, c: 3, d: 4, e: 5}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-own-property.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..6aa846a4b7dd989e5a52e28655d0af7b9a010701
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest object contains just soruce object's own properties (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+class C {
+ static async *method({ x, ...{y , z} } = o) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..9064a3cadcdddba81b8c67cde372cc0f3b61730f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+class C {
+ static async *method({...rest} = o) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba7b3c5ee122642d3e175c45e2d8d00a554ccfc1
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-dflt-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static-dflt.template
+/*---
+description: Rest object contains just unextracted data (static class expression async generator method (default parameter))
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({a, b, ...rest} = {x: 1, y: 2, a: 5, b: 3}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method().next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-empty.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a237980f3d1af54a0d1883fb7c846071d7dee51
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-empty.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-empty.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: No property access occurs for an "empty" object binding pattern (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ Runtime Semantics: BindingInitialization
+
+ ObjectBindingPattern : { }
+
+ 1. Return NormalCompletion(empty).
+---*/
+var accessCount = 0;
+var obj = Object.defineProperty({}, 'attr', {
+ get: function() {
+ accessCount += 1;
+ }
+});
+
+
+var callCount = 0;
+class C {
+ static async *method({}) {
+ assert.sameValue(accessCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method(obj).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..87ef2ea1a729ea4c06784ebbcdee2b738dc20219
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-arrow.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-arrow.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to arrow functions (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ arrow = () => {} }) {
+ assert.sameValue(arrow.name, 'arrow');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-class.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..e4bc1d06acb65f5a6cb9cf5ac529bd7a81ea46a5
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-class.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-class.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" classes (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ cls = class {}, xCls = class X {}, xCls2 = class { static name() {} } }) {
+ assert.sameValue(cls.name, 'cls');
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..98a65299d66fa24b87243eac42542faa0da5a484
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-cover.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-cover.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns `name` to "anonymous" functions "through" cover grammar (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ cover = (function () {}), xCover = (0, function() {}) }) {
+ assert.sameValue(cover.name, 'cover');
+ assert.notSameValue(xCover.name, 'xCover');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..f81ebbe6ad07fb759acbbffa0947e998f526cfc6
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-fn.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-fn.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" functions (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ fn = function () {}, xFn = function x() {} }) {
+ assert.sameValue(fn.name, 'fn');
+ assert.notSameValue(xFn.name, 'xFn');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..db6ac1b1ebd65f881269d9a31789b07ad36d6084
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-fn-name-gen.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-fn-name-gen.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: SingleNameBinding assigns name to "anonymous" generator functions (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ d. If IsAnonymousFunctionDefinition(Initializer) is true, then
+ i. Let hasNameProperty be HasOwnProperty(v, "name").
+ ii. ReturnIfAbrupt(hasNameProperty).
+ iii. If hasNameProperty is false, perform SetFunctionName(v,
+ bindingId).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ gen = function* () {}, xGen = function* x() {} }) {
+ assert.sameValue(gen.name, 'gen');
+ assert.notSameValue(xGen.name, 'xGen');
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..08b78a9f2779503d08db463bd41ca009cbdfde97
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-init-skipped.js
@@ -0,0 +1,71 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 6. If Initializer is present and v is undefined, then
+ [...]
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ static async *method({ w = counter(), x = counter(), y = counter(), z = counter() }) {
+ assert.sameValue(w, null);
+ assert.sameValue(x, 0);
+ assert.sameValue(y, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: null, x: 0, y: false, z: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b092be1cdacb2b272ef7d5eec1ad07c3066ef06
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-id-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x, }) {
+ assert.sameValue(x, 23);
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-init.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..04c490c9853ab408bd4700091fd0c1a2c0648c93
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" array binding pattern using initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..8741f7a68e709965a2c2af6dba65be849020dc3f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary-trailing-comma.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: [y], }) {
+ assert.sameValue(y,45);
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: [45] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary.js
new file mode 100644
index 0000000000000000000000000000000000000000..e14578d6f766a61a6bdfa44f1df5a55d5d8e4c6e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-ary.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-ary.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" array binding pattern not using initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: [x, y, z] = [4, 5, 6] }) {
+ assert.sameValue(x, 7);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, undefined);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: [7, undefined, ] }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init-skipped.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
new file mode 100644
index 0000000000000000000000000000000000000000..cef656eedc53625e417d73c3d206a269f6543873
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init-skipped.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init-skipped.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Destructuring initializer is not evaluated when value is not `undefined` (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ BindingElement : BindingPattern Initializeropt
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+---*/
+var initCount = 0;
+function counter() {
+ initCount += 1;
+}
+
+
+var callCount = 0;
+class C {
+ static async *method({ s: t = counter(), u: v = counter(), w: x = counter(), y: z = counter() }) {
+ assert.sameValue(t, null);
+ assert.sameValue(v, 0);
+ assert.sameValue(x, false);
+ assert.sameValue(z, '');
+ assert.sameValue(initCount, 0);
+
+ assert.throws(ReferenceError, function() {
+ s;
+ });
+ assert.throws(ReferenceError, function() {
+ u;
+ });
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ assert.throws(ReferenceError, function() {
+ y;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ s: null, u: 0, w: false, y: '' }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..ca0e9cb726b0807096d04a31a396d2cc14e8df62
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-init.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Binding as specified via property name, identifier, and initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: y = 33 }) {
+ assert.sameValue(y, 33);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
new file mode 100644
index 0000000000000000000000000000000000000000..ec9f401098b8826563a57daf8b4fc8685fcb05e8
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id-trailing-comma.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id-trailing-comma.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Trailing comma is allowed following BindingPropertyList (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3 Destructuring Binding Patterns
+
+ ObjectBindingPattern[Yield] :
+ { }
+ { BindingPropertyList[?Yield] }
+ { BindingPropertyList[?Yield] , }
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: y, }) {
+ assert.sameValue(y, 23);
+
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b7325f9169ed53437203d6aae4c4161c4c2eeba
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-id.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-id.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Binding as specified via property name and identifier (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ SingleNameBinding : BindingIdentifier Initializeropt
+
+ [...]
+ 8. Return InitializeReferencedBinding(lhs, v).
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ x: y }) {
+ assert.sameValue(y, 23);
+ assert.throws(ReferenceError, function() {
+ x;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ x: 23 }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj-init.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj-init.js
new file mode 100644
index 0000000000000000000000000000000000000000..5fcba9918e0deeb2e0047121a13f6da49e248838
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj-init.js
@@ -0,0 +1,70 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj-init.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" object binding pattern using initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ a. Let defaultValue be the result of evaluating Initializer.
+ b. Let v be GetValue(defaultValue).
+ c. ReturnIfAbrupt(v).
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, 4);
+ assert.sameValue(y, 5);
+ assert.sameValue(z, 6);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: undefined }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac135c076eb37a44b89896c1135eb8e271ed8183
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-prop-obj.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-prop-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Object binding pattern with "nested" object binding pattern not using initializer (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+
+ 13.3.3.7 Runtime Semantics: KeyedBindingInitialization
+
+ [...]
+ 3. If Initializer is present and v is undefined, then
+ [...]
+ 4. Return the result of performing BindingInitialization for BindingPattern
+ passing v and environment as arguments.
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({ w: { x, y, z } = { x: 4, y: 5, z: 6 } }) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 7);
+
+ assert.throws(ReferenceError, function() {
+ w;
+ });
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ w: { x: undefined, z: 7 } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-getter.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..488a7b633aa4a5b761d028a7a669bcf9428070f4
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-getter.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-getter.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var count = 0;
+
+
+var callCount = 0;
+class C {
+ static async *method({...x}) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({ get v() { count++; return 2; } }).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-nested-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..d74fdc5a5850a8e656da22b5cdb3780f3ab2305f
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-nested-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-nested-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var obj = {a: 3, b: 4};
+
+
+var callCount = 0;
+class C {
+ static async *method({a, b, ...{c, e}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+ assert.sameValue(e, 5);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-nested-rest.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..dbcb286bf2397f31fb36500baaf2dcd8e6621c11
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-nested-rest.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-nested-rest.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment and object rest desconstruction is allowed in that case. (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({a, b, ...{c, ...rest}}) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(c, 3);
+
+ assert.sameValue(rest.d, 4);
+ assert.sameValue(rest.e, 5);
+
+ verifyEnumerable(rest, "d");
+ verifyWritable(rest, "d");
+ verifyConfigurable(rest, "d");
+
+ verifyEnumerable(rest, "e");
+ verifyWritable(rest, "e");
+ verifyConfigurable(rest, "e");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({a: 1, b: 2, c: 3, d: 4, e: 5}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-own-property.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed60d93cd3817c7bfb16b4422e67adea1f55682e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-obj-own-property.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-obj-own-property.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest object contains just soruce object's own properties (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+
+var callCount = 0;
+class C {
+ static async *method({ x, ...{y , z} }) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf8201959093372738a963e65fff695638eb756a
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-skip-non-enumerable.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-skip-non-enumerable.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+var o = {a: 3, b: 4};
+Object.defineProperty(o, "x", { value: 4, enumerable: false });
+
+
+var callCount = 0;
+class C {
+ static async *method({...rest}) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(rest.x, undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method(o).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-val-obj.js b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-val-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6f96a814e110018fc2a8cdb9a07331c590ee90e
--- /dev/null
+++ b/test/language/statements/class/dstr-async-gen-meth-static-obj-ptrn-rest-val-obj.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-binding/obj-ptrn-rest-val-obj.case
+// - src/dstr-binding/default/cls-decl-async-gen-meth-static.template
+/*---
+description: Rest object contains just unextracted data (static class expression async generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ ClassDeclaration : class BindingIdentifier ClassTail
+
+ 1. Let className be StringValue of BindingIdentifier.
+ 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with
+ argument className.
+ [...]
+
+ 14.5.14 Runtime Semantics: ClassDefinitionEvaluation
+
+ 21. For each ClassElement m in order from methods
+ a. If IsStatic of m is false, then
+ b. Else,
+ Let status be the result of performing PropertyDefinitionEvaluation for
+ m with arguments F and false.
+ [...]
+
+ Runtime Semantics: PropertyDefinitionEvaluation
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+ { AsyncGeneratorBody }
+
+ 1. Let propKey be the result of evaluating PropertyName.
+ 2. ReturnIfAbrupt(propKey).
+ 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true.
+ Otherwise let strict be false.
+ 4. Let scope be the running execution context's LexicalEnvironment.
+ 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters,
+ AsyncGeneratorBody, scope, strict).
+ [...]
+
+---*/
+
+
+var callCount = 0;
+class C {
+ static async *method({a, b, ...rest}) {
+ assert.sameValue(rest.x, 1);
+ assert.sameValue(rest.y, 2);
+ assert.sameValue(rest.a, undefined);
+ assert.sameValue(rest.b, undefined);
+
+ verifyEnumerable(rest, "x");
+ verifyWritable(rest, "x");
+ verifyConfigurable(rest, "x");
+
+ verifyEnumerable(rest, "y");
+ verifyWritable(rest, "y");
+ verifyConfigurable(rest, "y");
+
+ callCount = callCount + 1;
+ }
+};
+
+C.method({x: 1, y: 2, a: 5, b: 3}).next().then(() => {
+ assert.sameValue(callCount, 1, 'invoked exactly once');
+}).then($DONE, $DONE);