diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-assignment.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-assignment.js
new file mode 100644
index 0000000000000000000000000000000000000000..950877a12be32830ce2825abc74dfc79afb920e2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-assignment.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-assignment.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let v2, vNull, vHole, vUndefined, vOob;
+
+let iterCount = 0;
+async function fn() {
+ for await ([v2 = 10, vNull = 11, vHole = 12, vUndefined = 13, vOob = 14] of [[2, null, , undefined]]) {
+ assert.sameValue(v2, 2);
+ assert.sameValue(vNull, null);
+ assert.sameValue(vHole, 12);
+ assert.sameValue(vUndefined, 13);
+ assert.sameValue(vOob, 14);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-evaluation-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-evaluation.js
similarity index 81%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-evaluation-fn.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-evaluation.js
index d3f1e2c31548cfbc4445e8a2b99e7558d2e9caee..11b44fc7d605c8c0d6b226f5585290dbc675f940 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-evaluation-fn.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-evaluation.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-evaluation-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-init-evaluation.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: The Initializer should only be evaluated if v is undefined. (for-await-of statement)
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,10 +24,10 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var flag1 = false, flag2 = false;
-var _;
+let flag1 = false, flag2 = false;
+let _;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([ _ = flag1 = true, _ = flag2 = true ] of [[14]]) {
assert.sameValue(flag1, false);
@@ -38,7 +38,9 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-arrow.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..d37fbbd1cbac25c003a2daf33e39875ce74f4cf4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-arrow.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-arrow.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let arrow;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ arrow = () => {} ] of [[]]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-class.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..c3466008779a0a039ddf76033548687fda4a3f5b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-class.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-class.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let xCls, cls, xCls2;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ xCls = class x {}, cls = class {}, xCls2 = class { static name() {} } ] of [[]]) {
+ assert(xCls.name !== 'xCls');
+ assert(xCls2.name !== 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-cover-gen.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-cover.js
similarity index 78%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-cover-gen.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-cover.js
index 3c9111e4a41f3f1470607d4cf2ee44c715047d56..a689324a9dad428897a1d52308571d1203d851f3 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-cover-gen.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-cover.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-cover-gen.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-cover.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement)
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -29,15 +29,13 @@ info: |
[...] 7. If Initializer is present and value is undefined and
IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
DestructuringAssignmentTarget are both true, then
- a. Let hasNameProperty be HasOwnProperty(v, "name").
- b. ReturnIfAbrupt(hasNameProperty).
- c. If hasNameProperty is false, perform SetFunctionName(v,
- GetReferencedName(lref)).
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
---*/
-var xCover, cover;
+let xCover, cover;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([ xCover = (0, function() {}), cover = (function() {}) ] of [[]]) {
assert(xCover.name !== 'xCover');
@@ -51,6 +49,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..c914dfe56b47110b29f060f7d4bf4e45278e6ebb
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-fn.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-fn.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let xFnexp, fnexp;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ xFnexp = function x() {}, fnexp = function() {} ] of [[]]) {
+ assert(xFnexp.name !== 'xFnexp');
+
+ assert.sameValue(fnexp.name, 'fnexp');
+ verifyNotEnumerable(fnexp, 'name');
+ verifyNotWritable(fnexp, 'name');
+ verifyConfigurable(fnexp, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-gen.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..99a8a981528b8f7a8f0de595e3d67c417f0c5ed2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-fn-name-gen.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-gen.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let xGen, gen;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ xGen = function* x() {}, gen = function*() {} ] of [[]]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-in.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-in.js
similarity index 82%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-in.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-in.js
index 7067339fccd52a9d86f014981f5bd6518dbadd15..51226d136341dec3bd47f3963409db3e27a9dfa1 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-in.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-in.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-in.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-init-in.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement)
+description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var x;
+let x;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([ x = 'x' in {} ] of [[]]) {
assert.sameValue(x, false);
@@ -35,6 +35,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-let.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..f986e64f300e67382e7579ea490e19398dd45949
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-let.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-let.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Value retrieval of Initializer obeys `let` semantics. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [let, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ x = y ] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(constructor, ReferenceError);
+}).then($DONE, $DONE);
+
+let y;
+
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-order.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-order.js
similarity index 82%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-order.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-order.js
index 01cbd0f9d70cc6d7992e1142bf45b434ba0d240b..a3dde14a3435770c0374e1e5137cbde5a9be2658 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-order.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-order.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-order.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-init-order.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: Initializer values should be assigned in left-to-right order. (for-await-of statement)
+description: Initializer values should be assigned in left-to-right order. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,10 +24,10 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var x = 0;
-var a, b;
+let x = 0;
+let a, b;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([ a = x += 1, b = x *= 2 ] of [[]]) {
assert.sameValue(a, 1);
@@ -38,6 +38,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-simple-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-simple-no-strict.js
similarity index 83%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-simple-no-strict.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-simple-no-strict.js
index 80488ea30c14ecff60f32d19e0c6f83a8d86ddfd..f8f7d98f461beefe11650dcc5768f6c2ad45af2e 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-simple-no-strict.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-simple-no-strict.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-simple-no-strict.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-init-simple-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement)
+description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, noStrict, async]
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var argument, eval;
+let argument, eval;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([arguments = 4, eval = 5] of [[]]) {
assert.sameValue(arguments, 4);
@@ -36,6 +36,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-yield-ident-invalid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..e18b86f212a2c227bcdb5eefca28596e55e8aff4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-yield-ident-invalid.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-yield-ident-invalid.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([ x = yield ] of [[]])
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..14c1dc8e8686af1a036304991d1042c11d2ec406
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-init-yield-ident-valid.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 4;
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ x = yield ] of [[]]) {
+ assert.sameValue(x, 4);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-iter-nrml-close.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-iter-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6fd9bc247c4319554d02a428338e1c056ff1ec6
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-iter-nrml-close.js
@@ -0,0 +1,81 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-nrml-close.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: IteratorClose is called when assignment evaluation has not exhausted the iterator (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 5. Return result.
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thisValue = null;
+let args = null;
+let _;
+let iterable = {};
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+let iterCount = 0;
+async function fn() {
+ for await ([ _ ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-invalid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..342f68f64fa2bc9466099760816803ee3c3476b1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-invalid.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-invalid.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([[(x, y)]] of [[[]]])
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..d98bee22a4586c2a010a2d187e945b2856da8478
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-null.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the value is `null`, a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([[ _ ]] of [[null]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined-hole.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..d25f624611963711d31a1a1a1748d3d0bfa36b34
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined-hole.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the value is a "hole", a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([[ _ ]] of [[ , ]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined-own.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..62354a280f30a4b7da45e21fb78855d0967a32d8
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined-own.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the value is `undefined`, a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([[ x ]] of [[undefined]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..41e754ed3d30380c62d2845dfdb29804132e376e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-undefined.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-undefined.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and no value is defined, a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+let iterCount = 0;
+async function fn() {
+ for await ([[ x ]] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-yield-ident-invalid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ad84996758b386df073f21a287da9971aa49040
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-yield-ident-invalid.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-yield-ident-invalid.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment outside of strict mode, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([[x[yield]]] of [[[]]])
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1a4e3dc51f6e5818d6ac1b7bc6172e0235890c9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array-yield-ident-valid.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment outside of strict mode, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 'prop';
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ([[x[yield]]] of [[[22]]]) {
+ assert.sameValue(x.prop, 22);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb381bb31224ea504648ff228b2bd182d886b2bf
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([[x]] of [[[1]]]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-invalid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..f9f9297cfb4a5ca1d8ec883ebf5f24bd7f74dbc2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-invalid.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-invalid.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: It is a Syntax Error if LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if the lexical token sequence matched by LeftHandSideExpression cannot be parsed with no tokens left over using AssignmentPattern as the goal symbol. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([{ get x() {} }] of [[{}]])
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..65bb92841f2b7fc67b2692e09d1dde3933e03dba
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-null.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the value is `null`, a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([{ x }] of [[null]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined-hole.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc0b0cbd88b47e8dd3945e1e5a1a2fdaf1bf0fc5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined-hole.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the value is a "hole", a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([{ x }] of [[ , ]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined-own.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..6bbc7142691efdf005be8cd0f88c08797aab5ac2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined-own.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the value is `undefined`, a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([{ x }] of [[undefined]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e9ef3d850182d9f01300e1ffd21427e5890afe4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-undefined.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-undefined.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and no value is defined, a TypeError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([{ x }] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-yield-ident-invalid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-yield-ident-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..256d892d0a633407913f457fe89008ac204da599
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-yield-ident-invalid.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-yield-ident-invalid.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment outside of a generator function body, it behaves as a IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([{ x = yield }] of [[{}]])
+}
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-obj-yield-ident-valid-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-yield-ident-valid.js
similarity index 83%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-nested-obj-yield-ident-valid-fn.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-yield-ident-valid.js
index 8d48973842019e61fd34c5b8e1728b8cd6222152..15ad49159f1acfc39fb7c66cd0d41956f1c1571b 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-obj-yield-ident-valid-fn.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj-yield-ident-valid.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-nested-obj-yield-ident-valid-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-nested-obj-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
/*---
-description: When a `yield` token appears within the Initializer of a nested destructuring assignment outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement)
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, noStrict, async]
@@ -24,10 +24,10 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var yield = 2;
-var x;
+let yield = 2;
+let x;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([{ x = yield }] of [[{}]]) {
assert.sameValue(x, 2);
@@ -37,7 +37,9 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-obj-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj.js
similarity index 85%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-nested-obj-fn.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj.js
index 35726a5819ffdce6ff74cea9099ecdf76cd8ab0b..fee0c7ca9bd0762c8b9b9543f3b4a8f050b6e165 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-obj-fn.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-nested-obj.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-nested-obj-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var x;
+let x;
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([{ x }] of [[{ x: 2 }]]) {
assert.sameValue(x, 2);
@@ -37,6 +37,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-const.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-const.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0704628a6d049e37e1599a6c738d5efb4947538
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-const.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-const.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The assignment target should obey `const` semantics. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [const, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+const c = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ([ c ] of [[1]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-let.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..1568df9dd5fe1dd62a1a1b4236ee700b103cbf43
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-let.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-let.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The assignment target should obey `let` semantics. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [let, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([ x ] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, ReferenceError);
+}).then($DONE, $DONE);
+
+let x;
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-put-prop-ref-no-get-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref-no-get.js
similarity index 84%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-put-prop-ref-no-get-fn.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref-no-get.js
index bf751d8fb9645e2b14a8885635446bf4ee885c51..e5b1aa0b87b6ae13790c42bb4091ed7dd0600be9 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-put-prop-ref-no-get-fn.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref-no-get.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-put-prop-ref-no-get-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-put-prop-ref-no-get.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement)
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,7 +24,7 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var x, setValue;
+let x, setValue;
x = {
get y() {
$ERROR('The property should not be accessed.');
@@ -34,7 +34,7 @@ x = {
}
};
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([x.y] of [[23]]) {
assert.sameValue(setValue, 23);
@@ -44,6 +44,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref-user-err.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref-user-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac096899f35f77f9f6fdd805a1afa3b0cff7937f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref-user-err.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-prop-ref-user-err.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Any error raised as a result of setting the value should be forwarded to the runtime. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {
+ set y(val) {
+ throw new Test262Error();
+ }
+};
+
+let iterCount = 0;
+async function fn() {
+ for await ([x.y] of [[23]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-put-prop-ref-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref.js
similarity index 80%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-put-prop-ref-fn.js
rename to test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref.js
index 52e30d420957b909af69dea12497077f21928f40..f0d8bb039892c6a2f157d8260c33e2601069f37a 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-put-prop-ref-fn.js
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-prop-ref.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-put-prop-ref-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment-for-await/array-elem-put-prop-ref.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
/*---
-description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement)
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement in an async function declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var x = {};
+let x = {};
-var iterCount = 0;
+let iterCount = 0;
async function fn() {
for await ([x.y] of [[4]]) {
assert.sameValue(x.y, 4);
@@ -36,6 +36,8 @@ async function fn() {
}
}
-fn()
+let promise = fn();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d3fc8d6cf2351c1a58f35f427cae6e8c03137a6
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-unresolvable-no-strict.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([ unresolvable ] of [[]]) {
+ assert.sameValue(unresolvable, undefined);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-unresolvable-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-unresolvable-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0482a7b3b6086d96b5c1eb2d406857b931428e5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-put-unresolvable-strict.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-unresolvable-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: In strict mode, if the the assignment target is an unresolvable reference, a ReferenceError should be thrown. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([ unresolvable ] of [[]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, ReferenceError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-identifier.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-identifier.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d92a6feb3485ae7807b220efaca27e9c5c35897
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-identifier.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-target-identifier.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y, z;
+
+let iterCount = 0;
+async function fn() {
+ for await ([x, y, z] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-simple-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-simple-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..77421b3d85211e05ce5db3c3e0b0b4c851b2003e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-simple-strict.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-target-simple-strict.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: It is a Syntax Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is false. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([arguments] of [[]])
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-yield-invalid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-yield-invalid.js
new file mode 100644
index 0000000000000000000000000000000000000000..6cbfb5ea2dafa3b859f6313c938c8a1dc7eb30d3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-yield-invalid.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-target-yield-invalid.case
+// - src/dstr-assignment-for-await/error-async-function-syntax/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+negative:
+ phase: early
+ type: SyntaxError
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+async function fn() {
+ for await ([ x[yield] ] of [[]])
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-yield-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-yield-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..80227cc3fced4d614933f9a1513051c8822cbcac
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-target-yield-valid.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-target-yield-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 'prop';
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ([ x[yield] ] of [[33]]) {
+ assert.sameValue(x.prop, 33);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..8bab2affad4392533094979c2924434b2a18a31f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-null.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-elision-iter-nrml-close-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+ [...]
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+ 9. If Type(innerResult.[[value]]) is not Object, throw a TypeError
+ exception.
+
+---*/
+let x;
+let nextCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function fn() {
+ for await ([ x , , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elision-val-array.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elision-val-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..450811515bdff9116b1f8449e451929bede47994
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elision-val-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elision-val-array.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ArrayAssignmentPattern containing only Elisions requires iterable values (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([,] of [[]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-elision-val-string.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-elision-val-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..c2af5a6fa94ce2ab020dbd4b6e5a69b0f6524492
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-elision-val-string.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elision-val-string.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ArrayAssignmentPattern containing only Elisions requires iterable values (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([,] of ['string literal'
+
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-empty-val-array.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-empty-val-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3ce7b4ff55b2519a0a23fa7555d25d0db7490e1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-empty-val-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-empty-val-array.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ArrayAssignmentPattern without an AssignmentElementList requires iterable values. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([] of [[]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-empty-val-string.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-empty-val-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..e1cc450e4caebb3e40fe705406d415fc879daeff
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-empty-val-string.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-empty-val-string.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ArrayAssignmentPattern without an AssignmentElementList requires iterable values. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([] of ['string literal'
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-element.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-element.js
new file mode 100644
index 0000000000000000000000000000000000000000..e20bcd3dca680e3771a64bab6e6527f15e7fbf05
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-element.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-after-element.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An AssignmentRestElement following an AssignmentElement consumes all remaining iterable values. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ([x, ...y] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y.length, 2);
+ assert.sameValue(y[0], 2);
+ assert.sameValue(y[1], 3);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-elision.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..42e76ee1441a9c460821ae13d30a19b8d21d5208
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-elision.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-after-elision.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An AssignmentRestElement following an elision consumes all remaining iterable values. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([, ...x] of [[1, 2, 3]]) {
+ assert.sameValue(x.length, 2);
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 3);
+
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-elision.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..ecaefd0220e82c002833fce9e66491b77a93b070
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-elision.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-elision.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: ArrayAssignmentPattern may include elisions at any position preceeding a AssignmentRestElement in a AssignmentElementList. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ([, , x, , ...y] of [[1, 2, 3, 4, 5, 6]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y.length, 2);
+ assert.sameValue(y[0], 5);
+ assert.sameValue(y[1], 6);
+
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-iteration.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf3b178cdd8b7f40a2b3c466022fd41760eb0120
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-iteration.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-iteration.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: In the presense of an AssignmentRestElement, value iteration exhausts the iterable value; (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let count = 0;
+let g = function*() {
+ count += 1;
+ yield;
+ count += 1;
+ yield;
+ count += 1;
+}
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...x] of [g()]) {
+ assert.sameValue(count, 3);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..937f233f43c194fc36190c96e58c2b6e6a4c3ef2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-null.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `null` as the only value, an array with a single `null` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...[x, y]] of [[null]]) {
+ assert.sameValue(x, null);
+ assert.sameValue(y, undefined);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined-hole.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..3e9e8a296d924bea0731b13d933d882f7dec9c76
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined-hole.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is an array with a "hole", an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...[x]] of [[ , ]]) {
+ assert.sameValue(x, undefined);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined-own.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..57c598b06c6a8c16a29d473327aca73be6e69162
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined-own.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `undefined` as the only value, an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...[x]] of [[undefined]]) {
+ assert.sameValue(x, undefined);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..21fa5b8bb0feb56a40b413669719247a9b69f65b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-undefined.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-undefined.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is emits no values, an empty array should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...[x]] of [[]]) {
+ assert.sameValue(x, undefined);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..9f20b8274a89ae66b8f771eb750a76554b66983a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array-yield-ident-valid.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierExpression. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 'prop';
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ([...[x[yield]]] of [[86]]) {
+ assert.sameValue(x.prop, 86);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..23c476d56e0f6294698b137ffeec8330ca01e8ac
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-array.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...[x]] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..e41c29f130db86f281b8eaf87acfb76a9cfa9e6d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-null.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the iterable emits `null` as the only value, an array with a single `null` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, length;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...{ 0: x, length }] of [[null]]) {
+ assert.sameValue(x, null);
+ assert.sameValue(length, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined-hole.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..d04ff74f95d7c2f7d86127a8954706aea9b82e8d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined-hole.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is an array with a "hole", an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...{ 0: x, length }] of [[ , ]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined-own.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a5954217cf5969a89937d462bd35e3449362c2f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined-own.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `undefined` as the only value, an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...{ 0: x, length }] of [[undefined]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..85158aa9487dabf7a30137c12a89e4be4407507c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-undefined.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-undefined.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an obect literal and the iterable is emits no values, an empty array should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...{ 0: x, length }] of [[]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 0);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..f06421c49bdc3dfe8c6c6b02a0f894c10c543a83
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj-yield-ident-valid.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierExpression. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 2;
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...{ x = yield }] of [[{}]]) {
+ assert.sameValue(x, 2);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..3879891fd29d97662aa1d13a899b34c10bdb1edc
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-nested-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ([...{ 1: x }] of [[1, 2, 3]]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-prop-ref-no-get.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..406fc70c3ab4d5023580297e7d946f42566ae9cb
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-prop-ref-no-get.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-put-prop-ref-no-get.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let setValue;
+let x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+let iterCount = 0;
+async function fn() {
+ for await ([...x.y] of [[23, 45, 99]]) {
+ assert.sameValue(setValue.length, 3);
+ assert.sameValue(setValue[0], 23);
+ assert.sameValue(setValue[1], 45);
+ assert.sameValue(setValue[2], 99);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-prop-ref.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..16d7b6b3853f07e5cc74a01d0ed93f047c60e3ef
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-prop-ref.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-put-prop-ref.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ([...x.y] of [[4, 3, 2]]) {
+ assert.sameValue(x.y.length, 3);
+ assert.sameValue(x.y[0], 4);
+ assert.sameValue(x.y[1], 3);
+ assert.sameValue(x.y[2], 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..b645e2ceff269b92abf403a9a2487b7ffbb8c8cc
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-put-unresolvable-no-strict.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ([ ...unresolvable ] of [[]]) {
+ assert.sameValue(unresolvable.length, 0);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8c6e5c6ab230b534ccec2e7c4fc8de5d5973f89
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-array-rest-yield-ident-valid.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentRestElement and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 'prop';
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ([...x[yield]] of [[33, 44, 55]]) {
+ assert.sameValue(x.prop.length, 3);
+ assert.sameValue(x.prop[0], 33);
+ assert.sameValue(x.prop[1], 44);
+ assert.sameValue(x.prop[2], 55);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-bool.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-bool.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bdd49d558962b287501ec0d339449998848f6df
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-bool.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-bool.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (boolean value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ({} of [false]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-num.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-num.js
new file mode 100644
index 0000000000000000000000000000000000000000..ea00d18b20c1a1e51eab951c3039408f84c53cfe
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-num.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-num.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (number value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ({} of [0
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-obj.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..d043fd783ac21ef30b844aec2783095fb9e7b370
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-obj.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-obj.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (object value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ({} of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-string.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..4363db4fe7dec468ecab8aa4096913643480cb6e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-string.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-string.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (string value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function fn() {
+ for await ({} of ['']) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-symbol.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-symbol.js
new file mode 100644
index 0000000000000000000000000000000000000000..7c2fbce1a58668e2b6e2dccf333fc6a33bff2ffd
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-empty-symbol.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-symbol.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (symbol value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let s = Symbol();
+
+let iterCount = 0;
+async function fn() {
+ for await ({} of [s]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-first.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-first.js
new file mode 100644
index 0000000000000000000000000000000000000000..0fec5c7ccc1d609b65b93d31958008fedbeec932
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-first.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-first.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (first of many) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x, y } of [{ x: 3 }]) {
+ assert.sameValue(x, 3);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-last.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-last.js
new file mode 100644
index 0000000000000000000000000000000000000000..b137be1b6935c2a4b1071f2ec6e71386acf90df8
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-last.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-last.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (last of many) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ w, x } of [{ x: 4 }]) {
+ assert.sameValue(x, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-lone.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-lone.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba0c7f092fb56f67f59fe0a12f38c011aae73658
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-lone.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-lone.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone identifier) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x, } of [{ x: 2 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-middle.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-middle.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c6a05303d3743868571850b1e990049b69f82c3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-middle.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-middle.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (within many) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ w, x, y } of [{ x: 5 }]) {
+ assert.sameValue(x, 5);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-trlng.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-trlng.js
new file mode 100644
index 0000000000000000000000000000000000000000..7805c9c86fe32353dda7c00ae3f790fc0a72b32d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-identifier-resolution-trlng.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-trlng.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone identifier with trailing comma) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x } of [{ x: 1 }]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-missing.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-missing.js
new file mode 100644
index 0000000000000000000000000000000000000000..099395f650cb22c1724ef17f2e5754ab8590299b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-missing.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-missing.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (no corresponding property defined). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x = 1 } of [{}]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..05f6eeb48fa7617bb8d00c13c9f3d65fd7d954da
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-null.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (null property value defined). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x = 1 } of [{ x: null }]) {
+ assert.sameValue(x, null);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-truthy.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-truthy.js
new file mode 100644
index 0000000000000000000000000000000000000000..d15398d3dfeea4e07bd043019aed112a68091a2d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-truthy.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-truthy.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (truthy property value defined). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x = 1 } of [{ x: 2 }]) {
+ assert.sameValue(x, 2);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-undef.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..00b64f49cb5d31f7cb2a7d46016f26cb13694022
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-assignment-undef.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-undef.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference ("undefined" property value defined). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x = 1 } of [{ x: undefined }]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-evaluation.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..0216a3c6263d0ab29734090b2c65f911f7aaa6ab
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-evaluation.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-evaluation.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let flag1 = false;
+let flag2 = false;
+let x, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x = flag1 = true, y = flag2 = true } of [{ y: 1 }]) {
+ assert.sameValue(flag1, true);
+ assert.sameValue(flag2, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-arrow.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..47b035cba2b7795c7d3b36ebff4dc4d87e7bf234
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-arrow.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-arrow.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let arrow;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ arrow = () => {} } of [{}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-class.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..c61d422d2ce4d1652f2b30232046fd125fbe1bb1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-class.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-class.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xCls, cls, xCls2;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ xCls = class x {}, cls = class {}, xCls2 = class { static name() {} } } of [{}]) {
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-cover.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d26765d6afb6b397b2956b3cfd77604fb3c2d91
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-cover.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-cover.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xCover, cover;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ xCover = (0, function() {}), cover = (function() {}) } of [{}]) {
+ assert.notSameValue(xCover.name, 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..64243ddd29149f34b71436313ebabf163f27d1e4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-fn.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-fn.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xFnexp, fnexp;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ xFnexp = function x() {}, fnexp = function() {} } of [{}]) {
+ assert.notSameValue(xFnexp.name, 'xFnexp');
+
+ assert.sameValue(fnexp.name, 'fnexp');
+ verifyNotEnumerable(fnexp, 'name');
+ verifyNotWritable(fnexp, 'name');
+ verifyConfigurable(fnexp, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-gen.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd47ab1ec22b76a985929d630c627a2f8e507f2e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-fn-name-gen.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-gen.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xGen, gen;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ xGen = function* x() {}, gen = function*() {} } of [{}]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-in.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce7d7c1ab972d9f505792a616bb23f1ec5f7058f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-in.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-in.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The Initializer in an AssignmentProperty may be an `in` expression. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let prop;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ prop = 'x' in {} } of [{}]) {
+ assert.sameValue(prop, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-order.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..1243e42645083d45f1060863acede488908974b4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-order.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-order.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Initializer values should be assigned in left-to-right order. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = 0;
+let a, b;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ a = x += 1, b = x *= 2 } of [{}]) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-simple-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..b6ef15a4586d44e35703c353e4e3bc8cda553d8e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-simple-no-strict.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-simple-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let eval, arguments;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ eval = 3, arguments = 4 } of [{}]) {
+ assert.sameValue(eval, 3);
+ assert.sameValue(arguments, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..64098b8d672d2c185faaa4d856b255ef998b0c7c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-init-yield-ident-valid.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentProperty and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 3;
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x = yield } of [{}]) {
+ assert.sameValue(x, 3);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..018ddf945cf69beb7b642613e833501e28af431e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-put-unresolvable-no-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+let iterCount = 0;
+async function fn() {
+ for await ({ unresolvable } of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => {
+ assert.sameValue(unresolvable, undefined);
+ assert.sameValue(iterCount, 1, 'iteration occurred as expected');
+ }, $DONE)
+ .then($DONE, $DONE);
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-simple-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..3c270eb3b8ca27cf768dc5a650bedd6665833c3e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-id-simple-no-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-simple-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let eval;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ eval } of [{ eval: 1 }]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => {
+ assert.sameValue(eval, 1);
+ assert.sameValue(iterCount, 1, 'iteration occurred as expected');
+ }, $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-missing.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-missing.js
new file mode 100644
index 0000000000000000000000000000000000000000..e0e4606d140de9d3e92080dcd6e638019478e12a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-missing.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-missing.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (non-existent property) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ y: x = 1 } of [{}]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-null.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..3feba3ed63f6ac801a44e8a49ea1bfa3f2dbec6e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-null.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-null.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is not undefined, the Initializer should be evaluated and the result assigned to the target reference (null value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ y: x = 1 } of [{ y: null }]) {
+ assert.sameValue(x, null);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-truthy.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-truthy.js
new file mode 100644
index 0000000000000000000000000000000000000000..bbf2d80ef99aad238f7737f5c5b586ed6c6aaf77
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-truthy.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-truthy.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is not undefined, the Initializer should be evaluated and the result assigned to the target reference (truthy value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ y: x = 1 } of [{ y: 2 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-undef.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c93cfcaafeaf7634434a5377beef407f80abb6a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-assignment-undef.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-undef.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (undefined value) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ y: x = 1 } of [{ y: undefined }]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-evaluation.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..0254c0f65186bc666bb15adc11acd17023fdca5c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-evaluation.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-evaluation.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let flag1 = false;
+let flag2 = false;
+let x, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: x = flag1 = true, y: y = flag2 = true } of [{ y: 1 }]) {
+ assert.sameValue(x, true, 'value of `x`');
+ assert.sameValue(flag1, true, 'value of `flag1`');
+ assert.sameValue(y, 1, 'value of `y`');
+ assert.sameValue(flag2, false, 'value of `flag2`');
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-arrow.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..4410301b6c2c104375779b4805d69b297141bba1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-arrow.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-arrow.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let arrow;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: arrow = () => {} } of [{}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-class.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..adb6ee92dfa011f4730e761ada82850741d89ebc
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-class.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-class.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xCls, cls, xCls2;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: xCls = class x {}, x: cls = class {}, x: xCls2 = class { static name() {} } } of [{}]) {
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-cover.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..e525e3533f7b8cb93257464fb1e735a611f493c9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-cover.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-cover.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xCover, cover;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: xCover = (0, function() {}), x: cover = (function() {}) } of [{}]) {
+ assert.notSameValue(xCover.name, 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-fn.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..3967466cbbcf164a960da9d774a9094632956073
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-fn.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-fn.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xFnexp, fnexp;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: xFnexp = function x() {}, x: fnexp = function() {} } of [{}]) {
+ assert.notSameValue(xFnexp.name, 'xFnexp');
+
+ assert.sameValue(fnexp.name, 'fnexp');
+ verifyNotEnumerable(fnexp, 'name');
+ verifyNotWritable(fnexp, 'name');
+ verifyConfigurable(fnexp, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-gen.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..a1bc7b21f27aa333683a034dfa54c36539d9f892
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-fn-name-gen.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-gen.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xGen, gen;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: xGen = function* x() {}, x: gen = function*() {} } of [{}]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-in.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..437406d99e3034d02587890462e3475b4f93d63d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-in.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-in.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let prop;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: prop = 'x' in {} } of [{}]) {
+ assert.sameValue(prop, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a319f5fb00255b721aef67589fdb5128bc4485a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-init-yield-ident-valid.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 4;
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: x = yield } of [{}]) {
+ assert.sameValue(x, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-target-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-target-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..a59bf84eba26b5905a94a7deb8061f62f9eb1e8a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-elem-target-yield-ident-valid.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-target-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 'prop';
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: x[yield] } of [{ x: 23 }]) {
+ assert.sameValue(x.prop, 23);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-first.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-first.js
new file mode 100644
index 0000000000000000000000000000000000000000..f49160babee5b8e6230424da632b8142e27abe49
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-first.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-first.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (first of many). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ a: x, y } of [{ a: 3 }]) {
+ assert.sameValue(x, 3);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-last.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-last.js
new file mode 100644
index 0000000000000000000000000000000000000000..1c6569f42023cae079103885a1b217cbf72c53e5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-last.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-last.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (last of many). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ w, a: x } of [{ a: 4 }]) {
+ assert.sameValue(x, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-lone.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-lone.js
new file mode 100644
index 0000000000000000000000000000000000000000..82a1baaec48806ef5e3e2f822918743cd2e22df0
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-lone.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-lone.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone element). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ a: x } of [{ a: 1 }]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-middle.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-middle.js
new file mode 100644
index 0000000000000000000000000000000000000000..04ae6c9056f56c8695de09f3ff7facf76e43a78e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-middle.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-middle.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (within many). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ w, a: x, y } of [{ a: 5 }]) {
+ assert.sameValue(x, 5);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-trlng.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-trlng.js
new file mode 100644
index 0000000000000000000000000000000000000000..526e2e45cd1d51a06221942b6b6155c32b993332
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-identifier-resolution-trlng.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-trlng.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone element with trailing comma). (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ a: x, } of [{ a: 2 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-name-evaluation.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-name-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..660647f93814266075b71faafee32e9089cc1868
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-name-evaluation.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-name-evaluation.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: PropertyName of an AssignmentProperty may be a ComputedPropertyName. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y, xy;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ ['x' + 'y']: x } of [{ x: 1, xy: 23, y: 2 }]) {
+ assert.sameValue(x, 23);
+ assert.sameValue(y, undefined);
+ assert.sameValue(xy, undefined);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-array-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..47b50cb80895fa164c0452cd6ff1124188f4bfd9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-array-yield-ident-valid.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-array-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 22;
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: [x = yield] } of [{ x: [] }]) {
+ assert.sameValue(x, 22);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-array.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..653983d5e2834d8d180391279924c9f8302d7d1c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-array.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: [y] } of [{ x: [321] }]) {
+ assert.sameValue(y, 321);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-obj-yield-ident-valid.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef51d1ab6bc16be50ee3a207b15c4840c1fc7c7c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-obj-yield-ident-valid.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-obj-yield-ident-valid.case
+// - src/dstr-assignment-for-await/async-function/async-func-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let yield = 2;
+let result, x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: { x = yield } } of [{ x: {} }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-obj.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..b8702c1af3341cd82744a6fa6b2a954f7ad547f0
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-nested-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let result, y;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: { y } } of [{ x: { y: 2 } }]) {
+ assert.sameValue(y, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-order.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..511c40d3666da2feb3cde24ca3279b4d210d6ea6
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-order.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-order.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The AssignmentElements in an AssignmentElementList are evaluated in left- to-right order. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ z: x, a: x } of [{ a: 2, z: 1 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-prop-ref-no-get.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..17f1a27d16b8f1ea2425d40afc33b56ceb45161f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-prop-ref-no-get.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-prop-ref-no-get.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let setValue;
+let x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+let iterCount = 0;
+async function fn() {
+ for await ({ a: x.y } of [{ a: 23 }]) {
+ assert.sameValue(setValue, 23);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-prop-ref.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5f16422d71a22d056433607b5994f9b5a9a5290
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-prop-ref.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-prop-ref.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ({ xy: x.y } of [{ xy: 4 }]) {
+ assert.sameValue(x.y, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..0a9f9620c7486d0975f12d5e611ad6444b2ac1af
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-prop-put-unresolvable-no-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x: unresolvable } of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => {
+ assert.sameValue(unresolvable, undefined);
+ assert.sameValue(iterCount, 1, 'iteration occurred as expected');
+ }, $DONE)
+ .then($DONE, $DONE);
+}
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-descriptors.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-descriptors.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7ddc432d486e307332674cb16589b4a93d05662
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-descriptors.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-descriptors.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Object created from rest deconstruction doesn't copy source object property descriptors. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+let obj = {};
+Object.defineProperty(obj, "a", { value: 3, configurable: false, enumerable: true });
+Object.defineProperty(obj, "b", { value: 4, writable: false, enumerable: true });
+
+let iterCount = 0;
+async function fn() {
+ for await ({...rest} of [obj]) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-empty-obj.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-empty-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..58b333f977d9bfd17c170b14ee8e2ef396a94f21
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-empty-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-empty-obj.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: RestBindingInitialization creates a new object even if lhs is an empty object (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ({...rest} of [{}]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert.sameValue(typeof rest, "object");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-getter.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d277d5d022afed0ee8b8e1aa256d2f1328c0524
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-getter.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-getter.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+let count = 0;
+
+let iterCount = 0;
+async function fn() {
+ for await ({...x} of [{ get v() { count++; return 2; } }]) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-nested-obj-nested-rest.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-nested-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..76bebde8c801ffa48bbf795b3541b780bbd62aa5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-nested-obj-nested-rest.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-nested-obj-nested-rest.case
+// - src/dstr-assignment-for-await/default/async-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. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let a, b, c, rest;
+
+let iterCount = 0;
+async function fn() {
+ for await ({a, b, ...{c, ...rest}} of [{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");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-nested-obj.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e9a477177cc856e36072cc39546c75530434bbf
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-nested-obj.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let a, b, c, d, e;
+
+let iterCount = 0;
+async function fn() {
+ for await ({a, b, ...{c, e}} of [{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);
+ assert.sameValue(d, undefined);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-number.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-number.js
new file mode 100644
index 0000000000000000000000000000000000000000..736ba41dc5b49ec595098e288e0037507739caa6
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-number.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-number.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: RestBindingInitialization creates a new object even if lhs is a Number (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ({...rest} of [51]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert(rest instanceof Object);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-obj-own-property.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..82bd5315a2061620a1640c61ecd6da544b6aa344
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-obj-own-property.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-obj-own-property.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Rest object contains just source object's own properties (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+let x, y, z;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x, ...{y , z} } of [o]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-same-name.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-same-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..15105324e2eeb24a21f51b80c8d7ec3603668a05
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-same-name.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-same-name.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Proper setting in the values for rest name equal to a property name. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let o = {
+ x: 42,
+ y: 39,
+ z: 'cheeseburger'
+};
+
+let x, y, z;
+
+let iterCount = 0;
+async function fn() {
+ for await ({ x, ...z } of [o]) {
+ assert.sameValue(x, 42);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z.y, 39);
+ assert.sameValue(z.z, 'cheeseburger');
+
+ let keys = Object.keys(z);
+ assert.sameValue(keys.length, 2);
+ assert.sameValue(keys[0], 'y');
+ assert.sameValue(keys[1], 'z');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-skip-non-enumerable.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f5416ab043220a560a8154387b6d8e0ef194fa9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-skip-non-enumerable.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-skip-non-enumerable.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+let obj = {a: 3, b: 4};
+Object.defineProperty(obj, "x", { value: 4, enumerable: false });
+
+let iterCount = 0;
+async function fn() {
+ for await ({...rest} of [obj]) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(Object.getOwnPropertyDescriptor(rest, "x"), undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-str-val.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-str-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..ee545af9e53e49e9f87347924df516ca268d724b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-str-val.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-str-val.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: RestBindingInitialization creats an object with indexes as property name (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ({...rest} of ["foo"]) {
+ assert.sameValue(rest["0"], "f");
+ assert.sameValue(rest["1"], "o");
+ assert.sameValue(rest["2"], "o");
+ assert(rest instanceof Object);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-symbol-val.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-symbol-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..2341fe81d57d994379ebd5298bf6ae526ae1353c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-symbol-val.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-symbol-val.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: RestBindingInitialization creates a new object if lhs is a Symbol (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ({...rest} of [Symbol("foo")]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert(rest instanceof Object);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-to-property-with-setter.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-to-property-with-setter.js
new file mode 100644
index 0000000000000000000000000000000000000000..92b6ca76fc165cdf356fb4b4dbe617fa510e4318
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-to-property-with-setter.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-to-property-with-setter.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object property setter, its value should be binded as rest object. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let settedValue;
+let executedGetter = false;
+let src = {
+ get y() {
+ executedGetter = true;
+ },
+ set y(v) {
+ settedValue = v;
+ },
+};
+src.y = undefined;
+
+let iterCount = 0;
+async function fn() {
+ for await ({...src.y} of [{ x: 1, y: 2}]) {
+ assert.sameValue(settedValue.x, 1);
+ assert.sameValue(settedValue.y, 2);
+ assert(!executedGetter, "The property should not be accessed");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-to-property.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-to-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a38884c3e1dae7e9468363eb708b33aeee8758f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-to-property.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-to-property.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object property, its value should be binded as rest object. (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let src = {};
+
+let iterCount = 0;
+async function fn() {
+ for await ({...src.y} of [{ x: 1, y: 2}]) {
+ assert.sameValue(src.y.x, 1);
+ assert.sameValue(src.y.y, 2);
+
+ verifyEnumerable(src, "y");
+ verifyWritable(src, "y");
+ verifyConfigurable(src, "y");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-valid-object.js b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-valid-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..cef75b021bcc49df297e6e11d5252769df8032cb
--- /dev/null
+++ b/test/language/statements/for-await-of/async-func-decl-dstr-obj-rest-valid-object.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-valid-object.case
+// - src/dstr-assignment-for-await/default/async-func-decl.template
+/*---
+description: Rest object contains just unextracted data (for-await-of statement in an async function declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest, a, b;
+
+
+let iterCount = 0;
+async function fn() {
+ for await ({a, b, ...rest} of [{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");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-assignment-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-assignment.js
similarity index 82%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-init-assignment-gen.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-assignment.js
index 0436b47c41726c553957eb0df87cad288924c909..4ff50c3105a17ecebb49dfd082f5417ec5f6c776 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-assignment-gen.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-assignment.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-assignment-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-elem-init-assignment.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
/*---
-description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference. (for-await-of statement)
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var v2, vNull, vHole, vUndefined, vOob;
+let v2, vNull, vHole, vUndefined, vOob;
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
for await ([v2 = 10, vNull = 11, vHole = 12, vUndefined = 13, vOob = 14] of [[2, null, , undefined]]) {
assert.sameValue(v2, 2);
@@ -40,6 +40,8 @@ async function * fn() {
}
}
-fn().next()
+let promise = fn().next();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-evaluation-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-evaluation.js
similarity index 81%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-init-evaluation-gen.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-evaluation.js
index 940dbecd196fdc9b62ea3fb138e716f11e2b204f..c22669357799196c60826da7fbe516da5f1e48d0 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-evaluation-gen.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-evaluation.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-evaluation-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-elem-init-evaluation.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
/*---
-description: The Initializer should only be evaluated if v is undefined. (for-await-of statement)
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,10 +24,10 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var flag1 = false, flag2 = false;
-var _;
+let flag1 = false, flag2 = false;
+let _;
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
for await ([ _ = flag1 = true, _ = flag2 = true ] of [[14]]) {
assert.sameValue(flag1, false);
@@ -38,7 +38,9 @@ async function * fn() {
}
}
-fn().next()
+let promise = fn().next();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-arrow-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-arrow.js
similarity index 78%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-arrow-gen.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-arrow.js
index 7418316daaa0353c4ab40211ad5cc7243256292b..ca79b100775e3e29cd2847276a44d7a45fce412e 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-arrow-gen.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-arrow.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-arrow-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-arrow.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
/*---
-description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement)
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -29,15 +29,13 @@ info: |
[...] 7. If Initializer is present and value is undefined and
IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
DestructuringAssignmentTarget are both true, then
- a. Let hasNameProperty be HasOwnProperty(v, "name").
- b. ReturnIfAbrupt(hasNameProperty).
- c. If hasNameProperty is false, perform SetFunctionName(v,
- GetReferencedName(lref)).
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
---*/
-var arrow;
+let arrow;
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
for await ([ arrow = () => {} ] of [[]]) {
assert.sameValue(arrow.name, 'arrow');
@@ -49,6 +47,8 @@ async function * fn() {
}
}
-fn().next()
+let promise = fn().next();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-class-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-class.js
similarity index 79%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-class-gen.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-class.js
index bfa07d1986edf3ce552010c9c7837b141b41b047..571f68c3793ea03745673f5f906c203b4b699981 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-class-gen.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-class.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-class-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-class.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
/*---
-description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement)
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [class, destructuring-binding, async-iteration]
flags: [generated, async]
@@ -29,15 +29,13 @@ info: |
[...] 7. If Initializer is present and value is undefined and
IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
DestructuringAssignmentTarget are both true, then
- a. Let hasNameProperty be HasOwnProperty(v, "name").
- b. ReturnIfAbrupt(hasNameProperty).
- c. If hasNameProperty is false, perform SetFunctionName(v,
- GetReferencedName(lref)).
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
---*/
-var xCls, cls, xCls2;
+let xCls, cls, xCls2;
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
for await ([ xCls = class x {}, cls = class {}, xCls2 = class { static name() {} } ] of [[]]) {
assert(xCls.name !== 'xCls');
@@ -53,7 +51,9 @@ async function * fn() {
}
}
-fn().next()
+let promise = fn().next();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-cover.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e64a556bf90767f08c0d102e4422ca61de10156
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-cover.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-cover.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let xCover, cover;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ xCover = (0, function() {}), cover = (function() {}) ] of [[]]) {
+ assert(xCover.name !== 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-fn.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..220dafebe1aa9f650279ff5370b3a6655690542e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-fn.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-fn.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let xFnexp, fnexp;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ xFnexp = function x() {}, fnexp = function() {} ] of [[]]) {
+ assert(xFnexp.name !== 'xFnexp');
+
+ assert.sameValue(fnexp.name, 'fnexp');
+ verifyNotEnumerable(fnexp, 'name');
+ verifyNotWritable(fnexp, 'name');
+ verifyConfigurable(fnexp, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..0d2967d03705ac6867bce54a9285ed51600822d9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-fn-name-gen.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-fn-name-gen.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and value is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(v, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
+
+---*/
+let xGen, gen;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ xGen = function* x() {}, gen = function*() {} ] of [[]]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-in.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..22c115576d65ae951480175446193dcfe67e3fd1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-in.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-in.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x = 'x' in {} ] of [[]]) {
+ assert.sameValue(x, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-let.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ea88b545b9c394c5b5db3b86de90817585498d1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-let.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-let.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Value retrieval of Initializer obeys `let` semantics. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [let, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x = y ] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(constructor, ReferenceError);
+}).then($DONE, $DONE);
+
+let y;
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-order.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..2d274a5ef2624bba5e47c6db930e4f1783319a65
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-order.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-order.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Initializer values should be assigned in left-to-right order. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = 0;
+let a, b;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ a = x += 1, b = x *= 2 ] of [[]]) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(x, 2);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-simple-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..0bbc13533c4c08c7f78fd6fe18eeaff5fea1758c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-simple-no-strict.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-simple-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let argument, eval;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([arguments = 4, eval = 5] of [[]]) {
+ assert.sameValue(arguments, 4);
+ assert.sameValue(eval, 5);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..c7326a7cf7d82a0ca702a9fe0c72535bb779f844
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-init-yield-expr.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-init-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement within a generator function body, it behaves as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let value = [];
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x = yield ] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x, undefined);
+
+ iter.next(4).then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x, 4);
+ }, $DONE).then($DONE, $DONE);
+}, $DONE).catch($DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-get-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-get-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..06cc1bb9f7a50024390a5009f5f7db6ab0c196c5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-get-err.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-get-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Abrupt completion returned from GetIterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ 1. Let iterator be ? GetIterator(value).
+
+---*/
+let iterable = {
+ [Symbol.iterator]() {
+ throw new Test262Error();
+ }
+};
+let _;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ _ ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..fff9646ad76f75b57db1d9c760a30f19b2cfed82
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-err.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-nrml-close-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Abrupt completion returned from IteratorClose (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let _;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ throw new Test262Error();
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ _ ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..45b6d5ac76119c9d580325948dd10db2795be6bb
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-null.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-nrml-close-null.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 5. Return result.
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[Type]] is throw, return Completion(completion).
+ 7. If innerResult.[[Type]] is throw, return Completion(innerResult).
+ 8. If Type(innerResult.[[Value]]) is not Object, throw a TypeError exception.
+
+---*/
+let _;
+let nextCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ _ ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..48b56ad877ea8642d47abc2301e383496b14ab65
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close-skip.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-nrml-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not called when assignment evaluation has exhausted the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 5. Return result.
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let _;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return() {
+ returnCount += 1;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ _ ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => {
+ assert.sameValue(iterCount, 1);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..7a6bf4ec0a74984d99f4fb4f913b7a077aab8b48
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-nrml-close.js
@@ -0,0 +1,81 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-nrml-close.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: IteratorClose is called when assignment evaluation has not exhausted the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 5. Return result.
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thisValue = null;
+let args = null;
+let _;
+let iterable = {};
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ _ ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-rtrn-close-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..78a15c3efbeec0ffbeb311633969187ba602bdf4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-rtrn-close-null.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-rtrn-close-null.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 5. Return result.
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[Type]] is throw, return Completion(completion).
+ 7. If innerResult.[[Type]] is throw, return Completion(innerResult).
+ 8. If Type(innerResult.[[Value]]) is not Object, throw a TypeError exception.
+
+---*/
+let unreachable = 0;
+let iterator = {
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ {}[yield] ] of [iterable]) {
+ unreachable += 1;
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(unreachable, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-thrw-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-thrw-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4fc72ee673275b1302a0364854c1049342ca413
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-iter-thrw-close-skip.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-iter-thrw-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not called when iteration produces an abrupt completion (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 5. Return result.
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ throw new Test262Error();
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+let _;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..6ef12924f97a4707f2d0bf74e920c28fb5df47a8
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-null.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the value is `null`, a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([[ _ ]] of [[null]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined-hole.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf93ae3a989291c49c26855b9a4ebb895b969cb1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined-hole.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the value is a "hole", a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([[ _ ]] of [[ , ]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined-own.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..7dad6808d3d63a55efc31d20b897f02971415ce3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined-own.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the value is `undefined`, a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([[ x ]] of [[undefined]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..e8a5458bd3af03c158c1ce56339b0847bb4a2ec9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-undefined.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-undefined.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and no value is defined, a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let _;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([[ x ]] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd39619679984a5146caaeec05da5a928fcdd08a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-array-yield-expr.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-array-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and within a generator function body, it behaves as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let value = [[22]];
+let x = {};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([[x[yield]]] of [value]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x.prop, undefined);
+
+ iter.next('prop').then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x.prop, 22);
+ }, $DONE).then($DONE, $DONE);
+}, $DONE).catch($DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..a642c64256a2c48f845031455566c2ec74769011
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-null.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the value is `null`, a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([{ x }] of [[null]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined-hole.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2a5713c348250d2ed79ea0919809a7ffd42dc70
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined-hole.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the value is a "hole", a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([{ x }] of [[ , ]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined-own.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c91bebeb512c32e2b3dfccd26d83b0f424f5c1a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined-own.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the value is `undefined`, a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([{ x }] of [[undefined]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3401d69027720483b6a06ff0b73b6e0de4c19ab
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-undefined.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-undefined.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and no value is defined, a TypeError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([{ x }] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..2fe7de8d2cfccff3803df97b54cec8aa1f0ff433
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj-yield-expr.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-nested-obj-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it behaves as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([{ x = yield }] of [[{}]]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x, undefined);
+
+ iter.next(4).then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x, 4);
+ }, $DONE).then($DONE, $DONE);
+}, $DONE).catch($DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-nested-obj-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj.js
similarity index 85%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-nested-obj-gen.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj.js
index 3f164e74f6a4574b4ac9b665e0cb0266a79572ec..2978d2c5b97d05b46368987dc08e49c7a35e73d2 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-nested-obj-gen.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-nested-obj.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-nested-obj-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-elem-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
/*---
-description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var x;
+let x;
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
for await ([{ x }] of [[{ x: 2 }]]) {
assert.sameValue(x, 2);
@@ -37,6 +37,8 @@ async function * fn() {
}
}
-fn().next()
+let promise = fn().next();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-const.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-const.js
new file mode 100644
index 0000000000000000000000000000000000000000..614f51176f2f5244a3aa18cd6121474791ac7de9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-const.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-const.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The assignment target should obey `const` semantics. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [const, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+const c = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ c ] of [[1]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-let.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-let.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac115be487f01c94dae5150c00cdf9848822b210
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-let.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-let.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The assignment target should obey `let` semantics. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [let, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x ] of [[]]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, ReferenceError);
+}).then($DONE, $DONE);
+
+let x;
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref-no-get.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d70340cc31d0e0c37bbebc1311c0ab2c55d4402
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref-no-get.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-prop-ref-no-get.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, setValue;
+x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([x.y] of [[23]]) {
+ assert.sameValue(setValue, 23);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref-user-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref-user-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb87181737a5764974ef8cf78887449f7b21fae3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref-user-err.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-prop-ref-user-err.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Any error raised as a result of setting the value should be forwarded to the runtime. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {
+ set y(val) {
+ throw new Test262Error();
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([x.y] of [[23]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..21e1ceed134cf762af934bdb9ddc2772f4c299ac
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-prop-ref.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-prop-ref.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([x.y] of [[4]]) {
+ assert.sameValue(x.y, 4);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-put-unresolvable-no-strict-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-unresolvable-no-strict.js
similarity index 81%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-put-unresolvable-no-strict-gen.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-unresolvable-no-strict.js
index 86647fda79ce60605d036211c939d39de2202bbd..a216d482402ea769a83b5c8957bf8afaa8824763 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-put-unresolvable-no-strict-gen.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-unresolvable-no-strict.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-put-unresolvable-no-strict-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-elem-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
/*---
-description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement)
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [destructuring-binding, async-iteration]
flags: [generated, noStrict, async]
@@ -25,16 +25,17 @@ info: |
[...]
---*/
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
for await ([ unresolvable ] of [[]]) {
assert.sameValue(unresolvable, undefined);
-
iterCount += 1;
}
}
-fn().next()
+let promise = fn().next();
+
+promise
.then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-unresolvable-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-unresolvable-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad1e69690927be44a1ca13aa64091352ecfddd64
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-put-unresolvable-strict.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-put-unresolvable-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: In strict mode, if the the assignment target is an unresolvable reference, a ReferenceError should be thrown. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, onlyStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ unresolvable ] of [[]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise.then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, ReferenceError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-simple-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-simple-no-strict.js
index 3d8861b8a1d8ec526c68a7d6d0daf39b2d110df9..af7c3b755a16bdef5d8fca817f2f2765923f33eb 100644
--- a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-simple-no-strict.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-simple-no-strict.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-target-simple-no-strict.case
-// - src/dstr-assignment-async-iteration/async-generator/async-gen-decl.template
+// - src/dstr-assignment-for-await/array-elem-target-simple-no-strict.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
/*---
description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -24,7 +24,7 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var argument, eval;
+let argument, eval;
let iterCount = 0;
async function * fn() {
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-yield-expr.js
index 19c4eb80033d40c9b47719004db20214de6b4429..7ab9a2b3df20bd46c8c956a01dda880b0f1d6c6c 100644
--- a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-yield-expr.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-target-yield-expr.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-target-yield-expr.case
-// - src/dstr-assignment-async-iteration/async-generator/async-gen-decl.template
+// - src/dstr-assignment-for-await/array-elem-target-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
/*---
description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement within a generator function body, it behaves as a YieldExpression. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -24,9 +24,9 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var value = [33];
-var x = {};
-var iterationResult;
+let value = [33];
+let x = {};
+let iterationResult;
let iterCount = 0;
@@ -46,8 +46,6 @@ iter.next().then(iterationResult => {
assert.sameValue(iterationResult.done, false);
assert.sameValue(x.prop, undefined);
- // TODO add iterCount
- //
iter.next('prop').then(iterationResult => {
assert.sameValue(iterationResult.value, undefined);
assert.sameValue(iterationResult.done, true);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-abpt.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-abpt.js
new file mode 100644
index 0000000000000000000000000000000000000000..81c2eb4337b2653742472c3c676e2ed4cc402486
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-abpt.js
@@ -0,0 +1,85 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-elision-iter-abpt.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Abrupt completion returned during evaluation of elision (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+ i. If iteratorRecord.[[done]] is false, return
+ IteratorClose(iterator, status).
+ ii. Return Completion(status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+
+ if (nextCount === 2) {
+ throw new Test262Error();
+ }
+
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+
+iter.next().then(() => {
+ iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 2);
+ assert.sameValue(returnCount, 0);
+ assert.sameValue(constructor, Test262Error);
+
+ }).then($DONE, $DONE);
+}, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..aca92cc738ee634ab9a6ddb86e29ca941e802990
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-err.js
@@ -0,0 +1,82 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-elision-iter-nrml-close-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Abrupt completion returned from IteratorClose (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+ [...]
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ throw new Test262Error();
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(nextCount, 2);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
+
+
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..55ffa40678ef4757f794cfe9b6c6a4c4856ebd97
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-null.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-elision-iter-nrml-close-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+ [...]
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+ 9. If Type(innerResult.[[value]]) is not Object, throw a TypeError
+ exception.
+
+---*/
+let x;
+let nextCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..958d507e8bcabe83316b4728e2b3e7375d866921
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close-skip.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-elision-iter-nrml-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose not invoked when elision exhausts the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 5. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+
+ [...]
+
+ 7. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ 9. Return Completion(status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+
+ return { done: nextCount > 1 };
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , , ] of [iterable]) {
+ assert.sameValue(nextCount, 2);
+ assert.sameValue(returnCount, 0);
+
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..021fb58380f5e3b1034aa644b5af12e78f787402
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-elision-iter-nrml-close.js
@@ -0,0 +1,93 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-elision-iter-nrml-close.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose invoked when elision does not exhaust the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 5. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+
+ [...]
+
+ 7. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thisValue = null;
+let args = null;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , , ] of [iterable]) {
+ assert.sameValue(nextCount, 2);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-get-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-get-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..5f2eb345662a9558aa2cba191e4456714d57d26e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-get-err.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-get-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Abrupt completion returned from GetIterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ 1. Let iterator be GetIterator(value).
+ 2. ReturnIfAbrupt(iterator).
+
+---*/
+let iterable = {
+ [Symbol.iterator]() {
+ throw new Test262Error();
+ }
+};
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ] of [iterable
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.return().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d4c45eea82dace69f594e86c2e8b552ef1d9e66
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-err.js
@@ -0,0 +1,78 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-nrml-close-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Abrupt completion returned from IteratorClose (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[Iterator]]: iterator, [[Done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ b. Return Completion(status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thrower = function() {
+ throw new Test262Error();
+};
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ throw new Test262Error();
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
+
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..95bd13242ab1bef200749d03ba46c995560a5ed6
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-null.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-nrml-close-null.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[Iterator]]: iterator, [[Done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[type]] is throw, return Completion(completion).
+ 7. If innerResult.[[type]] is throw, return Completion(innerResult).
+ 8. If Type(innerResult.[[value]]) is not Object, throw a TypeError
+ exception.
+
+---*/
+let x;
+let nextCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.return().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..5084b598a3bec29a0a4844bd1d36a380074a0194
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close-skip.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-nrml-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not invoked when evaluation of AssignmentElementList exhausts the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thrower = function() {
+ throw new Test262Error();
+};
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..2e6b38688dc00fcbe9ce01fc8f913a2413453453
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-nrml-close.js
@@ -0,0 +1,89 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-nrml-close.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is invoked when evaluation of AssignmentElementList completes without exhausting the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thisValue = null;
+let args = null;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f68ee6b521c0ca0423ec97cdeb55d1b0b4e5796
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-err.js
@@ -0,0 +1,77 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-rtrn-close-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is invoked when evaluation of AssignmentElementList returns a "return" completion and the iterator has not been marked as "done" (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[Iterator]]: iterator, [[Done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[type]] is throw, return Completion(completion).
+ 7. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+let returnCount = 0;
+let unreachable = 0;
+let iterator = {
+ return() {
+ returnCount += 1;
+
+ throw new Test262Error();
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ {}[yield] , ] of [iterable]) {
+ unreachable += 1;
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.return().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..d894b5440413b2c49559cdc6001a6646534a0e2a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close-null.js
@@ -0,0 +1,75 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-rtrn-close-null.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[Iterator]]: iterator, [[Done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[type]] is throw, return Completion(completion).
+ 7. If innerResult.[[type]] is throw, return Completion(innerResult).
+ 8. If Type(innerResult.[[value]]) is not Object, throw a TypeError
+ exception.
+
+---*/
+let iterator = {
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ {}[yield] , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.return().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, TypeError);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..32405bb5c43a3ff7caf61efc342623c4b47787f1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-rtrn-close.js
@@ -0,0 +1,85 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-rtrn-close.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is invoked when evaluation of AssignmentElementList returns a "return" completion and the iterator has not been marked as "done" (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 2. Let iteratorRecord be Record {[[Iterator]]: iterator, [[Done]]: false}.
+ 3. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 4. If status is an abrupt completion, then
+ a. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[type]] is throw, return Completion(completion).
+ 7. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+let returnCount = 0;
+let unreachable = 0;
+let thisValue = null;
+let args = null;
+let iterator = {
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ {}[yield] , ] of [iterable]) {
+ unreachable += 1;
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.return(888).then(result => {
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
+ assert.sameValue(result.value, 888);
+ assert(result.done, 'Iterator correctly closed');
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-thrw-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-thrw-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..abdb0d6eb1b4315c4deefbd58ab97d4488d54a66
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-list-thrw-close-skip.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-list-thrw-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not invoked when evaluation of AssignmentElementList returns an abrupt completion and the iterator has been marked as "done" (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 3. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 4. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 5. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let iterable = {};
+let thrower = function() {
+ throw new Test262Error();
+};
+let iterator = {
+ next() {
+ nextCount += 1;
+ throw new Test262Error();
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+ assert.sameValue(iterCount, 0);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-nrml-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e3d79b90db8e1590892d80dbde4c1693679dd82
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-nrml-close-skip.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-rest-nrml-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not called when rest element evaluation has exhausted the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 7. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ 8. Return Completion(status).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let x, y;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { value: nextCount, done: nextCount > 1 };
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ...y ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => {
+ iter.return().then(() => {
+ assert.sameValue(nextCount, 2, 'nextCount');
+ assert.sameValue(returnCount, 0, 'returnCount');
+ assert.sameValue(x, 1, 'x');
+ assert.sameValue(y.length, 0, 'y.length');
+ }).then($DONE, $DONE);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-err.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..c894d48a5547776a984d9a992e463fe4550d210c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-err.js
@@ -0,0 +1,86 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-rest-rtrn-close-err.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is called when AssignmentRestEvaluation produces a "return" completion due to reference evaluation (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 7. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ 8. Return Completion(status).
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[type]] is throw, return Completion(completion).
+ 7. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let unreachable = 0;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+
+ throw new Test262Error();
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ...{}[yield] ] of [iterable]) {
+ unreachable += 1;
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(() => {
+ iter.return().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(constructor, Test262Error);
+ }).then($DONE, $DONE);
+}).then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..c4ede1b4e25b94fe0383a1525a74540820808297
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elem-trlg-iter-rest-rtrn-close-null.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elem-trlg-iter-rest-rtrn-close-null.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 7. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, status).
+ 8. Return Completion(status).
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ 6. If completion.[[type]] is throw, return Completion(completion).
+ 7. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+let nextCount = 0;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ return null;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ x , ...{}[yield] ] of [iterable]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.return().then(() => $DONE('Promise incorrectly fulfilled.'), ({ constructor }) => {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(constructor, Test262Error);
+}).then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-iter-nrml-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb47f59334775be44be7e280dd55b1107a31afd4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-iter-nrml-close-skip.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elision-iter-nrml-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not called when iteration has exhausted the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elision ]
+
+ 1. Let iterator be ? GetIterator(value).
+
+ [...]
+
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result)..
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return() {
+ returnCount += 1;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-iter-nrml-close.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-iter-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..82f5adfcce2e207a3e0d8cdecad13b44ecf2421c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-iter-nrml-close.js
@@ -0,0 +1,86 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elision-iter-nrml-close.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is called when assignment evaluation has not exhausted the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elision ]
+
+ 1. Let iterator be ? GetIterator(value).
+
+ [...]
+
+ 4. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result)..
+ [...]
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thisValue = null;
+let args = null;
+let iterator = {
+ next() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-val-array.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-val-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ae1cc8ee09a3c5e9640a42f93b7dafe262df57c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-val-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elision-val-array.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ArrayAssignmentPattern containing only Elisions requires iterable values (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([,] of [[]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-val-string.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-val-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..c654c3e385d4115cc37ad144d20fe2fb1b19f2f3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-elision-val-string.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-elision-val-string.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ArrayAssignmentPattern containing only Elisions requires iterable values (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([,] of ['string literal'
+
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-iter-close.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..ce905c5b2cb226053652f86ebdeac8d20ac71136
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-iter-close.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-empty-iter-close.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Iterator is closed without iterating (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ ]
+
+ 1. Let iterator be GetIterator(value).
+ 2. ReturnIfAbrupt(iterator).
+ 3. Return IteratorClose(iterator, NormalCompletion(empty)).
+
+ 7.4.6 IteratorClose ( iterator, completion )
+
+ [...]
+ 5. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let thisValue = null;
+let args = null;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([] of [iterable]) {
+ assert.sameValue(nextCount, 0);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-val-array.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-val-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc879f15fd2a42eb2af37f6757092362f85f21b2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-val-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-empty-val-array.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ArrayAssignmentPattern without an AssignmentElementList requires iterable values. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([] of [[]
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-val-string.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-val-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..98bc00820c076bf9413fb20b48046b320aba2542
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-empty-val-string.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-empty-val-string.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ArrayAssignmentPattern without an AssignmentElementList requires iterable values. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([] of ['string literal'
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-after-element.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-after-element.js
new file mode 100644
index 0000000000000000000000000000000000000000..6edf0788782d84819e2eaa34d7defde687b7f8ef
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-after-element.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-after-element.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An AssignmentRestElement following an AssignmentElement consumes all remaining iterable values. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([x, ...y] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y.length, 2);
+ assert.sameValue(y[0], 2);
+ assert.sameValue(y[1], 3);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-after-elision.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-after-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..b6c0c7cecd4dd603aa9009932063a7ea3659e6ae
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-after-elision.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-after-elision.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An AssignmentRestElement following an elision consumes all remaining iterable values. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([, ...x] of [[1, 2, 3]]) {
+ assert.sameValue(x.length, 2);
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 3);
+
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-elision.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..7215b7fd3b3dad282fab29b5dc4b7dec05c58007
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-elision.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-elision.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: ArrayAssignmentPattern may include elisions at any position preceeding a AssignmentRestElement in a AssignmentElementList. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([, , x, , ...y] of [[1, 2, 3, 4, 5, 6]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y.length, 2);
+ assert.sameValue(y[0], 5);
+ assert.sameValue(y[1], 6);
+
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-iter-nrml-close-skip.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d514f2ab8f3960b5f5bdc3c1d863b0c4bf99bd2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-iter-nrml-close-skip.js
@@ -0,0 +1,69 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-iter-nrml-close-skip.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: IteratorClose is not called when assignment evaluation has exhausted the iterator (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 4. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 5. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+ 6. Return result.
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let x;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ ...x ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-iteration.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..82b9a8e8fc6a8530c196c0ed2c538f5dc676e210
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-iteration.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-iteration.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: In the presense of an AssignmentRestElement, value iteration exhausts the iterable value; (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let count = 0;
+let g = function*() {
+ count += 1;
+ yield;
+ count += 1;
+ yield;
+ count += 1;
+}
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...x] of [g()]) {
+ assert.sameValue(count, 3);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-lref.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-lref.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f9b8ee660ae38fa52029a9ad7be4f4372aa47dd
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-lref.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-lref.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: Reference is evaluated during assignment (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 4. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 5. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iterator, result).
+
+
+ AssignmentRestElement[Yield] : ... DestructuringAssignmentTarget
+
+ 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an
+ ArrayLiteral, then
+ a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+ b. ReturnIfAbrupt(lref).
+ [...]
+
+---*/
+let nextCount = 0;
+let returnCount = 0;
+let iterator = {
+ next() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return() {
+ returnCount += 1;
+ }
+};
+let obj = {};
+let iterable = {
+ [Symbol.iterator]() {
+ return iterator;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...obj['a' + 'b']] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+ assert(!!obj.ab);
+ assert.sameValue(obj.ab.length, 0);
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next()
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..511825c414575dbb135821845d32ec950880672d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-null.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `null` as the only value, an array with a single `null` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...[x, y]] of [[null]]) {
+ assert.sameValue(x, null);
+ assert.sameValue(y, undefined);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined-hole.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..19a853a8d52eaaea578306eee8fda85671c594f8
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined-hole.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is an array with a "hole", an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...[x]] of [[ , ]]) {
+ assert.sameValue(x, undefined);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined-own.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..a11440e335f4ebb70e1bc8b0226dbcf772f7be2e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined-own.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `undefined` as the only value, an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...[x]] of [[undefined]]) {
+ assert.sameValue(x, undefined);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c85dcbdfd7d69abfb0a77ffbd0041fad5f2b43d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-undefined.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-undefined.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is emits no values, an empty array should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...[x]] of [[]]) {
+ assert.sameValue(x, undefined);
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..041d0d7fd07c26f19a4255beb7b119c7fa711611
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array-yield-expr.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...[x[yield]]] of [[86]]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(iterationResult => {
+ assert.sameValue(iterationResult.value, undefined);
+ assert.sameValue(iterationResult.done, false);
+ assert.sameValue(x.prop, undefined);
+
+ iter.next('prop').then(iterationResult => {
+ assert.sameValue(iterationResult.value, undefined);
+ assert.sameValue(iterationResult.done, true);
+ assert.sameValue(x.prop, 86);
+ }).then($DONE, $DONE);
+});
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb5268cc93e126e1c63ec1b0cd9ab1b0e2d4a485
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-array.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-array.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...[x]] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..d730729e5583261e09d4218ddd4d4f1b10a22116
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-null.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the iterable emits `null` as the only value, an array with a single `null` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, length;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...{ 0: x, length }] of [[null]]) {
+ assert.sameValue(x, null);
+ assert.sameValue(length, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined-hole.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..f971f904842ab6eaf9f0bb3c0d3fba1225ef50e4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined-hole.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-undefined-hole.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is an array with a "hole", an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...{ 0: x, length }] of [[ , ]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined-own.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0507a733b655f9928dae904df630830318ba1b9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined-own.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-undefined-own.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `undefined` as the only value, an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...{ 0: x, length }] of [[undefined]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b77a5557076438695ba1546c9797943e99b3429
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-undefined.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj-undefined.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an obect literal and the iterable is emits no values, an empty array should be used as the value of the nested DestructuringAssignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...{ 0: x, length }] of [[]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 0);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-nested-obj-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-yield-expr.js
similarity index 81%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-nested-obj-yield-expr.js
rename to test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-yield-expr.js
index b23b78e865d795af24948b7e93a37fc47ef418b1..49238f2e6b66d9f5c35f0a6b530b0d32ed00f56e 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-nested-obj-yield-expr.js
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj-yield-expr.js
@@ -1,8 +1,8 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-nested-obj-yield-expr.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment-for-await/array-rest-nested-obj-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
/*---
-description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it behaves as a YieldExpression. (for-await-of statement)
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
features: [generators, destructuring-binding, async-iteration]
flags: [generated, async]
@@ -24,21 +24,18 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
-var iter, x;
+let x;
-
-var iterCount = 0;
+let iterCount = 0;
async function * fn() {
- for await ([{ x = yield }] of [[{}]]) {
+ for await ([...{ x = yield }] of [[{}]]) {
iterCount += 1;
}
}
-
-
-iter = fn();
+let iter = fn();
iter.next().then(iterationResult => {
assert.sameValue(iterationResult.value, undefined);
@@ -51,3 +48,4 @@ iter.next().then(iterationResult => {
assert.sameValue(x, 4);
}).then($DONE, $DONE);
});
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..87dccffda18437e66fbf91f214cce29d9615b759
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-nested-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...{ 1: x }] of [[1, 2, 3]]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-prop-ref-no-get.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..87b4c363209c56a31512d8ce5721a30dd7b77f92
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-prop-ref-no-get.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-put-prop-ref-no-get.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let setValue;
+let x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...x.y] of [[23, 45, 99]]) {
+ assert.sameValue(setValue.length, 3);
+ assert.sameValue(setValue[0], 23);
+ assert.sameValue(setValue[1], 45);
+ assert.sameValue(setValue[2], 99);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-prop-ref.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0145afb4a4732e1e243a120715afc18cabf35bf
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-prop-ref.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-put-prop-ref.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...x.y] of [[4, 3, 2]]) {
+ assert.sameValue(x.y.length, 3);
+ assert.sameValue(x.y[0], 4);
+ assert.sameValue(x.y[1], 3);
+ assert.sameValue(x.y[2], 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d67f952e58f2cb8646f66b14a805ce8021894f8
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-put-unresolvable-no-strict.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ([ ...unresolvable ] of [[]]) {
+ assert.sameValue(unresolvable.length, 0);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..c38b76c306c5c6fe7cde0893dfda7a69aa4e4362
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-array-rest-yield-expr.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/array-rest-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentRestElement and within the body of a generator function, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ([...x[yield]] of [[33, 44, 55]]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(iterationResult => {
+ assert.sameValue(iterationResult.value, undefined);
+ assert.sameValue(iterationResult.done, false);
+ assert.sameValue(x.prop, undefined);
+
+ iter.next('prop').then(iterationResult => {
+ assert.sameValue(iterationResult.value, undefined);
+ assert.sameValue(iterationResult.done, true);
+ assert.sameValue(x.prop.length, 3);
+ assert.sameValue(x.prop[0], 33);
+ assert.sameValue(x.prop[1], 44);
+ assert.sameValue(x.prop[2], 55);
+ assert.sameValue(iterCount, 1);
+ }).then($DONE, $DONE);
+});
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-bool.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-bool.js
new file mode 100644
index 0000000000000000000000000000000000000000..090bd94492570398ad135132539eea7e7b336067
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-bool.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-bool.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (boolean value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ({} of [false]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-num.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-num.js
new file mode 100644
index 0000000000000000000000000000000000000000..e3bd2cdba4f4f9bfb1cc9b4346ff5e7984bab234
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-num.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-num.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (number value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ({} of [0
+]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-obj.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..40d8e52b29ad1156c1e5aec67e38d92d6402aeeb
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-obj.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-obj.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (object value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ({} of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-string.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad649a92ac90f99e401bef63be0e815a922cd0e1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-string.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-string.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (string value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+let iterCount = 0;
+async function * fn() {
+ for await ({} of ['']) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-symbol.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-symbol.js
new file mode 100644
index 0000000000000000000000000000000000000000..92f73117fdc6654135ba51ae19d1e1fc152fa3d1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-empty-symbol.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-empty-symbol.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (symbol value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let s = Symbol();
+
+let iterCount = 0;
+async function * fn() {
+ for await ({} of [s]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-first.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-first.js
new file mode 100644
index 0000000000000000000000000000000000000000..623cb316380f04bf3b3db4526f734890d5e0de9f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-first.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-first.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (first of many) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x, y } of [{ x: 3 }]) {
+ assert.sameValue(x, 3);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-last.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-last.js
new file mode 100644
index 0000000000000000000000000000000000000000..14f9b5c01f2640e81acd7593f9aa67ae1de610c9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-last.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-last.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (last of many) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ w, x } of [{ x: 4 }]) {
+ assert.sameValue(x, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-lone.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-lone.js
new file mode 100644
index 0000000000000000000000000000000000000000..b9b48d609efebc0271fb3fbbc90f6f4bd1dfc592
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-lone.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-lone.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone identifier) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x, } of [{ x: 2 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-middle.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-middle.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c83bf79f32c1ccaf6a9f6df034c7cabdc18e9c1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-middle.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-middle.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (within many) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ w, x, y } of [{ x: 5 }]) {
+ assert.sameValue(x, 5);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-trlng.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-trlng.js
new file mode 100644
index 0000000000000000000000000000000000000000..f721e4638c823ff2a02f884561315fb0726154c3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-identifier-resolution-trlng.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-identifier-resolution-trlng.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone identifier with trailing comma) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x } of [{ x: 1 }]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-missing.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-missing.js
new file mode 100644
index 0000000000000000000000000000000000000000..72cbb9e182232b928f73dd2eacc5e242a079d81f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-missing.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-missing.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (no corresponding property defined). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x = 1 } of [{}]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..95b3564ea36c8682c5662de3a19550e921dab265
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-null.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (null property value defined). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x = 1 } of [{ x: null }]) {
+ assert.sameValue(x, null);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-truthy.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-truthy.js
new file mode 100644
index 0000000000000000000000000000000000000000..49d69d2122ae25fdf912b557779ef912244b1271
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-truthy.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-truthy.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (truthy property value defined). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x = 1 } of [{ x: 2 }]) {
+ assert.sameValue(x, 2);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-undef.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..cfbe786cb6557b6fcbeb25ddfc0f6495c9a26ecc
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-assignment-undef.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-assignment-undef.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference ("undefined" property value defined). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x = 1 } of [{ x: undefined }]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-evaluation.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..8fb37ae92bf19dcfb84dde1231119b5d01ef6fa7
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-evaluation.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-evaluation.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let flag1 = false;
+let flag2 = false;
+let x, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x = flag1 = true, y = flag2 = true } of [{ y: 1 }]) {
+ assert.sameValue(flag1, true);
+ assert.sameValue(flag2, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-arrow.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..7579a790d3bb5b5d284ed17d6bf47a8f91e93b7d
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-arrow.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-arrow.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let arrow;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ arrow = () => {} } of [{}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-class.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..35276008797c2b4c62ce4741b584cc3b778f7693
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-class.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-class.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xCls, cls, xCls2;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ xCls = class x {}, cls = class {}, xCls2 = class { static name() {} } } of [{}]) {
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-cover.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..de402137d6f1fb6eafb264b6ec5f7826f4bd2c46
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-cover.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-cover.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xCover, cover;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ xCover = (0, function() {}), cover = (function() {}) } of [{}]) {
+ assert.notSameValue(xCover.name, 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-fn.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..ecc562de9c75d10623e675ecdb572f19f99afc6e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-fn.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-fn.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xFnexp, fnexp;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ xFnexp = function x() {}, fnexp = function() {} } of [{}]) {
+ assert.notSameValue(xFnexp.name, 'xFnexp');
+
+ assert.sameValue(fnexp.name, 'fnexp');
+ verifyNotEnumerable(fnexp, 'name');
+ verifyNotWritable(fnexp, 'name');
+ verifyConfigurable(fnexp, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..513ded20ca955904af4de6214bba9402bdae3f61
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-fn-name-gen.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-fn-name-gen.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+let xGen, gen;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ xGen = function* x() {}, gen = function*() {} } of [{}]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-in.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..577f0bd3a5ce02867fd9c1fb0caff4d942ad7caf
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-in.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-in.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The Initializer in an AssignmentProperty may be an `in` expression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let prop;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ prop = 'x' in {} } of [{}]) {
+ assert.sameValue(prop, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-order.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ad78bc40843b0270906e70acca82db39ff2316e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-order.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-order.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Initializer values should be assigned in left-to-right order. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = 0;
+let a, b;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ a = x += 1, b = x *= 2 } of [{}]) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-simple-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..e62cf6d4976a565aed755b7d976962425a7c0a94
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-simple-no-strict.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-simple-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let eval, arguments;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ eval = 3, arguments = 4 } of [{}]) {
+ assert.sameValue(eval, 3);
+ assert.sameValue(arguments, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..999d5a89f95d7ec88ddb31285f84361b5a7a8161
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-init-yield-expr.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-init-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentProperty and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x = yield } of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x, undefined);
+
+ iter.next(3).then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x, 3);
+ }).then($DONE, $DONE);
+});
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..7c60e913a77206a74e0a9e582fef4a459870722a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-put-unresolvable-no-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ unresolvable } of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => {
+ assert.sameValue(unresolvable, undefined);
+ assert.sameValue(iterCount, 1, 'iteration occurred as expected');
+ }, $DONE)
+ .then($DONE, $DONE);
+}
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-simple-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..02f8525a762210c013086be7d6487d79e0769e50
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-id-simple-no-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-id-simple-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let eval;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ eval } of [{ eval: 1 }]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => {
+ assert.sameValue(eval, 1);
+ assert.sameValue(iterCount, 1, 'iteration occurred as expected');
+ }, $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-missing.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-missing.js
new file mode 100644
index 0000000000000000000000000000000000000000..e2f0f559418d234f0a24facca0ff5d033a77f68f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-missing.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-missing.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (non-existent property) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ y: x = 1 } of [{}]) {
+ assert.sameValue(x, 1);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-null.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8f2c8eccfa13d036ecb2319356fc3cd9727cd42
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-null.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-null.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is not undefined, the Initializer should be evaluated and the result assigned to the target reference (null value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ y: x = 1 } of [{ y: null }]) {
+ assert.sameValue(x, null);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-truthy.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-truthy.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf8694c14c124ee6a406a9cb9ea2cfaac41221f8
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-truthy.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-truthy.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is not undefined, the Initializer should be evaluated and the result assigned to the target reference (truthy value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ y: x = 1 } of [{ y: 2 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-undef.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..3cc674501e17a8bff57cef3b8a9d60fc87e968aa
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-assignment-undef.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-assignment-undef.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (undefined value) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ y: x = 1 } of [{ y: undefined }]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-evaluation.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa3f3db43ce65ad30518b7bb3a4b1070db5d0339
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-evaluation.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-evaluation.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let flag1 = false;
+let flag2 = false;
+let x, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: x = flag1 = true, y: y = flag2 = true } of [{ y: 1 }]) {
+ assert.sameValue(x, true, 'value of `x`');
+ assert.sameValue(flag1, true, 'value of `flag1`');
+ assert.sameValue(y, 1, 'value of `y`');
+ assert.sameValue(flag2, false, 'value of `flag2`');
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-arrow.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..e5381995805778ab0a453aec515b5c41a20bd18c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-arrow.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-arrow.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let arrow;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: arrow = () => {} } of [{}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-class.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..f5226d2a6e7b01568c94b73625e642dc904f7591
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-class.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-class.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xCls, cls, xCls2;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: xCls = class x {}, x: cls = class {}, x: xCls2 = class { static name() {} } } of [{}]) {
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-cover.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..6f8eeaddae8d5a6702544ccdf4513937c6f35ba5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-cover.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-cover.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xCover, cover;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: xCover = (0, function() {}), x: cover = (function() {}) } of [{}]) {
+ assert.notSameValue(xCover.name, 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-fn.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..19117fb53ba027f7b77edfb374ff7bd86e7acdaf
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-fn.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-fn.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xFnexp, fnexp;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: xFnexp = function x() {}, x: fnexp = function() {} } of [{}]) {
+ assert.notSameValue(xFnexp.name, 'xFnexp');
+
+ assert.sameValue(fnexp.name, 'fnexp');
+ verifyNotEnumerable(fnexp, 'name');
+ verifyNotWritable(fnexp, 'name');
+ verifyConfigurable(fnexp, 'name');
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-gen.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..123a0b1256cd3e76e9ac2a9842fd9a3d5330dbb7
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-fn-name-gen.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-fn-name-gen.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 6. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
+ b. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
+
+---*/
+let xGen, gen;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: xGen = function* x() {}, x: gen = function*() {} } of [{}]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-in.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..40e68cb4b5037e4a04c9f5f66b85fbcf1c185fbc
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-in.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-in.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let prop;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: prop = 'x' in {} } of [{}]) {
+ assert.sameValue(prop, false);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..8edc6fa36f8d06aaabd371090e0b87545cb00bb3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-init-yield-expr.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-init-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: x = yield } of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x, undefined);
+
+ iter.next(86).then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x, 86);
+ }).then($DONE, $DONE);
+});
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-target-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-target-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..5782eee952f87cdcfd3f22d9fc3f9193b9c00b5f
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-elem-target-yield-expr.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-elem-target-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: x[yield] } of [{ x: 23 }]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x.prop, undefined);
+
+ iter.next('prop').then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x.prop, 23);
+ }).then($DONE, $DONE);
+});
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-first.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-first.js
new file mode 100644
index 0000000000000000000000000000000000000000..667f3f6cf41f26a50f75937143bb43274ad29be2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-first.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-first.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (first of many). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ a: x, y } of [{ a: 3 }]) {
+ assert.sameValue(x, 3);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-last.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-last.js
new file mode 100644
index 0000000000000000000000000000000000000000..0278acdf8a1e19b4a90129c56b9201758e70d1c7
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-last.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-last.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (last of many). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ w, a: x } of [{ a: 4 }]) {
+ assert.sameValue(x, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-lone.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-lone.js
new file mode 100644
index 0000000000000000000000000000000000000000..00a81f302d2d16439da16a89f44ddf0b6d4aa7ff
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-lone.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-lone.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone element). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ a: x } of [{ a: 1 }]) {
+ assert.sameValue(x, 1);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-middle.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-middle.js
new file mode 100644
index 0000000000000000000000000000000000000000..e4218776f53e94d2e52775b02d62acac8832cab0
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-middle.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-middle.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (within many). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+let w, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ w, a: x, y } of [{ a: 5 }]) {
+ assert.sameValue(x, 5);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-trlng.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-trlng.js
new file mode 100644
index 0000000000000000000000000000000000000000..d80b71c28afbae1c61488048974045111bede6b4
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-identifier-resolution-trlng.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-identifier-resolution-trlng.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone element with trailing comma). (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = null;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ a: x, } of [{ a: 2 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-name-evaluation.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-name-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd0127a36836a805fe9f10bff431984fab454d9c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-name-evaluation.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-name-evaluation.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: PropertyName of an AssignmentProperty may be a ComputedPropertyName. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x, y, xy;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ ['x' + 'y']: x } of [{ x: 1, xy: 23, y: 2 }]) {
+ assert.sameValue(x, 23);
+ assert.sameValue(y, undefined);
+ assert.sameValue(xy, undefined);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-array-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..b81bfe9044592a587c16b7c12deeb6f427f9026b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-array-yield-expr.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-array-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: [x = yield] } of [{ x: [] }]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x, undefined);
+
+ iter.next(24601).then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x, 24601);
+ }).then($DONE, $DONE);
+});
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-array.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..132142a1b7b59577b269f360fd0c7283961f75b2
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-array.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-array.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: [y] } of [{ x: [321] }]) {
+ assert.sameValue(y, 321);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-obj-yield-expr.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..40746e8402845bf25abf30768cf5114fcd4b5d1c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-obj-yield-expr.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-obj-yield-expr.case
+// - src/dstr-assignment-for-await/async-generator/async-gen-decl.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = undefined;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: { x = yield } } of [{ x: {} }]) {
+
+ iterCount += 1;
+ }
+}
+
+let iter = fn();
+
+iter.next().then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, false);
+ assert.sameValue(x, undefined);
+
+ iter.next(4).then(result => {
+ assert.sameValue(result.value, undefined);
+ assert.sameValue(result.done, true);
+ assert.sameValue(x, 4);
+ }).then($DONE, $DONE);
+});
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-obj.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..f295b2d9fa429c7aa9a7a304fbbc9601f8b35ee6
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-nested-obj.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let result, y;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: { y } } of [{ x: { y: 2 } }]) {
+ assert.sameValue(y, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-order.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..85dca9df61fb6cbcaf49b6b1a7bf35c0bfd8c3bd
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-order.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-order.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The AssignmentElements in an AssignmentElementList are evaluated in left- to-right order. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ z: x, a: x } of [{ a: 2, z: 1 }]) {
+ assert.sameValue(x, 2);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-prop-ref-no-get.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..4b4dfda3f2109765d1b312119239e25918e14b4e
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-prop-ref-no-get.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-prop-ref-no-get.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let setValue;
+let x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ a: x.y } of [{ a: 23 }]) {
+ assert.sameValue(setValue, 23);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-prop-ref.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..f31790d2c895612af8533544bf6013672f1fda8a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-prop-ref.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-prop-ref.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x = {};
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ xy: x.y } of [{ xy: 4 }]) {
+ assert.sameValue(x.y, 4);
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d8efa080aec45ba0fde7302cea56ab4adc1248c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-prop-put-unresolvable-no-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-prop-put-unresolvable-no-strict.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x: unresolvable } of [{}]) {
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => {
+ assert.sameValue(unresolvable, undefined);
+ assert.sameValue(iterCount, 1, 'iteration occurred as expected');
+ }, $DONE)
+ .then($DONE, $DONE);
+}
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-descriptors.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-descriptors.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b7d6457d5519ae91eeeee38e98d6ae61d6a4c1b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-descriptors.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-descriptors.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Object created from rest deconstruction doesn't copy source object property descriptors. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+let obj = {};
+Object.defineProperty(obj, "a", { value: 3, configurable: false, enumerable: true });
+Object.defineProperty(obj, "b", { value: 4, writable: false, enumerable: true });
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...rest} of [obj]) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-empty-obj.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-empty-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3328de5bdee810c2a8ff052cf3975a4baf23cfb
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-empty-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-empty-obj.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: RestBindingInitialization creates a new object even if lhs is an empty object (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...rest} of [{}]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert.sameValue(typeof rest, "object");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-getter.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b3a527c638b19929793f543ccd3fa1f80a024a3
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-getter.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-getter.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let x;
+let count = 0;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...x} of [{ get v() { count++; return 2; } }]) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-nested-obj-nested-rest.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-nested-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..468ac18a9c7742ce10ad0f16475ff4c5e0b9522b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-nested-obj-nested-rest.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-nested-obj-nested-rest.case
+// - src/dstr-assignment-for-await/default/async-gen-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. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let a, b, c, rest;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({a, b, ...{c, ...rest}} of [{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");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-nested-obj.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..8575520e3dd506cc50d853772de1b7cab60c0a3c
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-nested-obj.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-nested-obj.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let a, b, c, d, e;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({a, b, ...{c, e}} of [{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);
+ assert.sameValue(d, undefined);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-number.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-number.js
new file mode 100644
index 0000000000000000000000000000000000000000..60b2313ef2e57db3b930017ef0df1ec68c1cfbd9
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-number.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-number.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: RestBindingInitialization creates a new object even if lhs is a Number (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...rest} of [51]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert(rest instanceof Object);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-obj-own-property.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..bb13d0af3ecd41bbcc04d6c26a280a9d17d09225
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-obj-own-property.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-obj-own-property.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Rest object contains just source object's own properties (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+let x, y, z;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x, ...{y , z} } of [o]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-same-name.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-same-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e3f2bc946fd8bc4875a0060f6657accd88e5010
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-same-name.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-same-name.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Proper setting in the values for rest name equal to a property name. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let o = {
+ x: 42,
+ y: 39,
+ z: 'cheeseburger'
+};
+
+let x, y, z;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({ x, ...z } of [o]) {
+ assert.sameValue(x, 42);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z.y, 39);
+ assert.sameValue(z.z, 'cheeseburger');
+
+ let keys = Object.keys(z);
+ assert.sameValue(keys.length, 2);
+ assert.sameValue(keys[0], 'y');
+ assert.sameValue(keys[1], 'z');
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-skip-non-enumerable.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..41e2fa3ab74ee493ddb27940c78ca5d1880e2275
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-skip-non-enumerable.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-skip-non-enumerable.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+let obj = {a: 3, b: 4};
+Object.defineProperty(obj, "x", { value: 4, enumerable: false });
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...rest} of [obj]) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(Object.getOwnPropertyDescriptor(rest, "x"), undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-str-val.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-str-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..78de67532891f9168e0e5b7325aed81a9c091de5
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-str-val.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-str-val.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: RestBindingInitialization creats an object with indexes as property name (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...rest} of ["foo"]) {
+ assert.sameValue(rest["0"], "f");
+ assert.sameValue(rest["1"], "o");
+ assert.sameValue(rest["2"], "o");
+ assert(rest instanceof Object);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-symbol-val.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-symbol-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..cb27c04118e79cb5900dd1af77a1ffc5aed5318b
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-symbol-val.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-symbol-val.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: RestBindingInitialization creates a new object if lhs is a Symbol (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...rest} of [Symbol("foo")]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert(rest instanceof Object);
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-to-property-with-setter.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-to-property-with-setter.js
new file mode 100644
index 0000000000000000000000000000000000000000..0554c4c0c55b956ec911b1e68c40338d7f9469cf
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-to-property-with-setter.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-to-property-with-setter.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object property setter, its value should be binded as rest object. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let settedValue;
+let executedGetter = false;
+let src = {
+ get y() {
+ executedGetter = true;
+ },
+ set y(v) {
+ settedValue = v;
+ },
+};
+src.y = undefined;
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...src.y} of [{ x: 1, y: 2}]) {
+ assert.sameValue(settedValue.x, 1);
+ assert.sameValue(settedValue.y, 2);
+ assert(!executedGetter, "The property should not be accessed");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-to-property.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-to-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8dee82d6aa9f2fe02077c42db858a8cd9f9640a
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-to-property.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-to-property.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: When DestructuringAssignmentTarget is an object property, its value should be binded as rest object. (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let src = {};
+
+let iterCount = 0;
+async function * fn() {
+ for await ({...src.y} of [{ x: 1, y: 2}]) {
+ assert.sameValue(src.y.x, 1);
+ assert.sameValue(src.y.y, 2);
+
+ verifyEnumerable(src, "y");
+ verifyWritable(src, "y");
+ verifyConfigurable(src, "y");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-valid-object.js b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-valid-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa701621cd20871c8c32c31ecd3597f3924003e1
--- /dev/null
+++ b/test/language/statements/for-await-of/async-gen-decl-dstr-obj-rest-valid-object.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment-for-await/obj-rest-valid-object.case
+// - src/dstr-assignment-for-await/default/async-gen-decl.template
+/*---
+description: Rest object contains just unextracted data (for-await-of statement in an async generator declaration)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+let rest, a, b;
+
+
+let iterCount = 0;
+async function * fn() {
+ for await ({a, b, ...rest} of [{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");
+
+ iterCount += 1;
+ }
+}
+
+let promise = fn().next();
+
+promise
+ .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-assignment-fn.js b/test/language/statements/for-await-of/dstr-array-elem-init-assignment.js
similarity index 83%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-assignment-fn.js
rename to test/language/statements/for-await-of/dstr-array-elem-init-assignment.js
index b293809c0dbca9b697da6429af3b4b8a886a48bb..4ec79f5c34a279f7423ffcc6d8275468ed39a010 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-assignment-fn.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-assignment.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-assignment-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-init-assignment.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference. (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -26,7 +26,8 @@ info: |
---*/
var v2, vNull, vHole, vUndefined, vOob;
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([v2 = 10, vNull = 11, vHole = 12, vUndefined = 13, vOob = 14] of [[2, null, , undefined]]) {
assert.sameValue(v2, 2);
@@ -34,12 +35,10 @@ async function fn() {
assert.sameValue(vHole, 12);
assert.sameValue(vUndefined, 13);
assert.sameValue(vOob, 14);
-
-
- iterCount += 1;
+ counter += 1;
}
}
fn()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-init-evaluation.js b/test/language/statements/for-await-of/dstr-array-elem-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b76dff98d7cc86c4a2883a585dc2088ad8739da
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-evaluation.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-init-evaluation.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var flag1 = false, flag2 = false;
+var _;
+
+var counter = 0;
+
+async function fn() {
+ for await ([ _ = flag1 = true, _ = flag2 = true ] of [[14]]) {
+ assert.sameValue(flag1, false);
+ assert.sameValue(flag2, true);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-arrow-fn.js b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-arrow.js
similarity index 85%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-arrow-fn.js
rename to test/language/statements/for-await-of/dstr-array-elem-init-fn-name-arrow.js
index 7428724d0f0e560bb2fb4a8f08ac094514f7aab8..fea2d852e29b4a8a98a1ff7abfd060dc111654f9 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-arrow-fn.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-arrow.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-arrow-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-init-fn-name-arrow.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -37,18 +37,18 @@ info: |
---*/
var arrow;
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([ arrow = () => {} ] of [[]]) {
assert.sameValue(arrow.name, 'arrow');
verifyNotEnumerable(arrow, 'name');
verifyNotWritable(arrow, 'name');
verifyConfigurable(arrow, 'name');
-
- iterCount += 1;
+ counter += 1;
}
}
fn()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-class-fn.js b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-class.js
similarity index 86%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-class-fn.js
rename to test/language/statements/for-await-of/dstr-array-elem-init-fn-name-class.js
index 88fb18c4855897c77bf1083b5afec2dc33457585..37525edcd44ce0068119634652e97afce9c382b3 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-class-fn.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-class.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-class-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-init-fn-name-class.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -37,7 +37,8 @@ info: |
---*/
var xCls, cls, xCls2;
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([ xCls = class x {}, cls = class {}, xCls2 = class { static name() {} } ] of [[]]) {
assert(xCls.name !== 'xCls');
@@ -47,13 +48,10 @@ async function fn() {
verifyNotEnumerable(cls, 'name');
verifyNotWritable(cls, 'name');
verifyConfigurable(cls, 'name');
-
-
- iterCount += 1;
+ counter += 1;
}
}
fn()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
-
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-cover-fn.js b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-cover.js
similarity index 86%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-cover-fn.js
rename to test/language/statements/for-await-of/dstr-array-elem-init-fn-name-cover.js
index f555a07115f19940c4ac02895faa9ec30c4b5532..fa0fa636c8466c79a548c07d70c118b30767929a 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-cover-fn.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-cover.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-cover-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-init-fn-name-cover.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -37,7 +37,8 @@ info: |
---*/
var xCover, cover;
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([ xCover = (0, function() {}), cover = (function() {}) ] of [[]]) {
assert(xCover.name !== 'xCover');
@@ -46,11 +47,10 @@ async function fn() {
verifyNotEnumerable(cover, 'name');
verifyNotWritable(cover, 'name');
verifyConfigurable(cover, 'name');
-
- iterCount += 1;
+ counter += 1;
}
}
fn()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-fn.js b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-fn.js
similarity index 86%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-fn.js
rename to test/language/statements/for-await-of/dstr-array-elem-init-fn-name-fn.js
index e8a71bb44bc2c5dd13290b9be819d60a80cbaa72..429355375d74e9afc87a8f4bc64cdbaa293a9844 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-init-fn-name-fn.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-fn.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-init-fn-name-fn.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -37,7 +37,8 @@ info: |
---*/
var xFn, fn;
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([ xFn = function x() {}, fn = function() {} ] of [[]]) {
assert(xFn.name !== 'xFn');
@@ -46,11 +47,10 @@ async function fn() {
verifyNotEnumerable(fn, 'name');
verifyNotWritable(fn, 'name');
verifyConfigurable(fn, 'name');
-
- iterCount += 1;
+ counter += 1;
}
}
fn()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-gen.js b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-gen.js
similarity index 85%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-gen.js
rename to test/language/statements/for-await-of/dstr-array-elem-init-fn-name-gen.js
index 6d3002df707d302798f8249ccf75d216ef922f67..4bfd1114657f0bd418aa899d6dab42a15e9fe286 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-init-fn-name-gen.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-fn-name-gen.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-init-fn-name-gen.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment/array-elem-init-fn-name-gen.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -37,8 +37,9 @@ info: |
---*/
var xGen, gen;
-var iterCount = 0;
-async function * fn() {
+var counter = 0;
+
+async function fn() {
for await ([ xGen = function* x() {}, gen = function*() {} ] of [[]]) {
assert.notSameValue(xGen.name, 'xGen');
@@ -46,11 +47,10 @@ async function * fn() {
verifyNotEnumerable(gen, 'name');
verifyNotWritable(gen, 'name');
verifyConfigurable(gen, 'name');
-
- iterCount += 1;
+ counter += 1;
}
}
-fn().next()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-init-in.js b/test/language/statements/for-await-of/dstr-array-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c35d84b243e893efc3867607aa6ee384842ff92
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-in.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-init-in.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x = 'x' in {} ] of [[]]) {
+ assert.sameValue(x, false);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-init-order.js b/test/language/statements/for-await-of/dstr-array-elem-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..e145fda73d8e1c2623b4de948efbed4ec8ffad2d
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-order.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-init-order.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Initializer values should be assigned in left-to-right order. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = 0;
+var a, b;
+
+var counter = 0;
+
+async function fn() {
+ for await ([ a = x += 1, b = x *= 2 ] of [[]]) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-init-simple-no-strict.js b/test/language/statements/for-await-of/dstr-array-elem-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..91d88807a277f583c96df09276bdc2d71fba8019
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-simple-no-strict.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-init-simple-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var argument, eval;
+
+var counter = 0;
+
+async function fn() {
+ for await ([arguments = 4, eval = 5] of [[]]) {
+ assert.sameValue(arguments, 4);
+ assert.sameValue(eval, 5);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-init-yield-expr.js b/test/language/statements/for-await-of/dstr-array-elem-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b967873395470037cfaf32cce4f72b142734221
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-yield-expr.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-init-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement within a generator function body, it behaves as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var value = [];
+var iterationResult, iter, x;
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x = yield ] of [[]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+})();
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(86);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 86);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-init-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-array-elem-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..cccf1aec0ad48676caf94dd2ff3c6ba85236ebda
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-init-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-init-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 4;
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x = yield ] of [[]]) {
+ assert.sameValue(x, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-iter-nrml-close-skip.js b/test/language/statements/for-await-of/dstr-array-elem-iter-nrml-close-skip.js
similarity index 83%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-iter-nrml-close-skip.js
rename to test/language/statements/for-await-of/dstr-array-elem-iter-nrml-close-skip.js
index 8a4a11adf82c5146ec96aa67ad30dba6ef4ee5c8..b891fef4f681a9974ec52f53abf8006965fa6590 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-iter-nrml-close-skip.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-iter-nrml-close-skip.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-iter-nrml-close-skip.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment/array-elem-iter-nrml-close-skip.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: IteratorClose is not called when assignment evaluation has exhausted the iterator (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -49,16 +49,16 @@ iterable[Symbol.iterator] = function() {
return iterator;
};
-var iterCount = 0;
-async function * fn() {
+var counter = 0;
+
+async function fn() {
for await ([ _ ] of [iterable]) {
assert.sameValue(nextCount, 1);
assert.sameValue(returnCount, 0);
-
- iterCount += 1;
+ counter += 1;
}
}
-fn().next()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-gen-dstr-array-elem-iter-nrml-close.js b/test/language/statements/for-await-of/dstr-array-elem-iter-nrml-close.js
similarity index 86%
rename from test/language/statements/for-await-of/async-gen-dstr-array-elem-iter-nrml-close.js
rename to test/language/statements/for-await-of/dstr-array-elem-iter-nrml-close.js
index 767e1b4c0ee03481223f39b82cf586809222892f..b73afb2079e01b9a0cdd15f509902f620aca3bc8 100644
--- a/test/language/statements/for-await-of/async-gen-dstr-array-elem-iter-nrml-close.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-iter-nrml-close.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-iter-nrml-close.case
-// - src/dstr-assignment-async-iteration/async-generator/for-await-of-async-gen.template
+// - src/dstr-assignment/array-elem-iter-nrml-close.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: IteratorClose is called when assignment evaluation has not exhausted the iterator (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -62,19 +62,19 @@ iterable[Symbol.iterator] = function() {
return iterator;
};
-var iterCount = 0;
-async function * fn() {
+var counter = 0;
+
+async function fn() {
for await ([ _ ] of [iterable]) {
assert.sameValue(nextCount, 1);
assert.sameValue(returnCount, 1);
assert.sameValue(thisValue, iterator, 'correct `this` value');
assert(!!args, 'arguments object provided');
assert.sameValue(args.length, 0, 'zero arguments specified');
-
- iterCount += 1;
+ counter += 1;
}
}
-fn().next()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close-err.js b/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..18efa99076c0709733d8f43365fe0bf55c35d008
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close-err.js
@@ -0,0 +1,79 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-iter-rtrn-close-err.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when reference evaluation produces a "return" completion (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 5. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+ 6. Return result.
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var returnCount = 0;
+var unreachable = 0;
+var iterable = {};
+var iterator = {
+ return: function() {
+ returnCount += 1;
+ throw new Test262Error();
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ {}[ yield ] ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+iter = g();
+iter.next();
+assert.throws(Test262Error, function() {
+ iter.return();
+});
+
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
diff --git a/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close-null.js b/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..ef43fceeee189abddcc39f81e81a442160f59ae2
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close-null.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-iter-rtrn-close-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 5. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+ 6. Return result.
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+ 9. If Type(innerResult.[[value]]) is not Object, throw a TypeError
+ exception.
+
+---*/
+var iterable = {};
+var iterator = {
+ return: function() {
+ return null;
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ {}[yield] ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+
+assert.throws(TypeError, function() {
+ iter.return();
+});
diff --git a/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close.js b/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..303d64a37f32ae79202d7c63b0453b9db5585be2
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-iter-rtrn-close.js
@@ -0,0 +1,86 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-iter-rtrn-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when reference evaluation produces a "return" completion (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ AssignmentElementList ]
+
+ [...]
+ 5. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+ 6. Return result.
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var returnCount = 0;
+var unreachable = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var iterator = {
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+var iter, result;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ {}[yield] ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+iter = g();
+iter.next();
+result = iter.return(777);
+
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
+assert.sameValue(result.value, 777);
+assert(result.done, 'Iterator correctly closed');
+assert.sameValue(thisValue, iterator, 'correct `this` value');
+assert(!!args, 'arguments object provided');
+assert.sameValue(args.length, 0, 'zero arguments specified');
diff --git a/test/language/statements/for-await-of/dstr-array-elem-nested-array-yield-expr.js b/test/language/statements/for-await-of/dstr-array-elem-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..9ad3e282be29996c54075451f606ea3721bbc44f
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-nested-array-yield-expr.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-nested-array-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and within a generator function body, it behaves as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var value = [[22]];
+var x = {};
+var iterationResult, iter;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([[x[yield]]] of [value]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 22);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-array-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-array-elem-nested-array-yield-ident-valid.js
similarity index 82%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-nested-array-yield-ident-valid.js
rename to test/language/statements/for-await-of/dstr-array-elem-nested-array-yield-ident-valid.js
index 129ee714bc56432ff2934af8e4226a9f19ea1d28..e11b2b4c6c6de99df593d2b92e8bd4666d9443b7 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-array-yield-ident-valid.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-nested-array-yield-ident-valid.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-nested-array-yield-ident-valid.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-nested-array-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment outside of strict mode, it behaves as an IdentifierReference. (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -27,10 +27,15 @@ info: |
var yield = 'prop';
var x = {};
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([[x[yield]]] of [[[22]]]) {
assert.sameValue(x.prop, 22);
- iterCount += 1;
+ counter += 1;
}
}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-array.js b/test/language/statements/for-await-of/dstr-array-elem-nested-array.js
similarity index 82%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-nested-array.js
rename to test/language/statements/for-await-of/dstr-array-elem-nested-array.js
index 593906b97f4e0d1d598fb4de5605841e9524a2ee..d6b92ee4792d096a83b8c34d445ffc75a83561a3 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-nested-array.js
+++ b/test/language/statements/for-await-of/dstr-array-elem-nested-array.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-nested-array.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/array-elem-nested-array.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -26,10 +26,15 @@ info: |
---*/
var x;
-var iterCount = 0;
+var counter = 0;
+
async function fn() {
for await ([[x]] of [[[1]]]) {
assert.sameValue(x, 1);
- iterCount += 1;
+ counter += 1;
}
}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-nested-obj-yield-expr.js b/test/language/statements/for-await-of/dstr-array-elem-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c33ed58e358feb27338d4852f31561191edc82c
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-nested-obj-yield-expr.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-nested-obj-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it behaves as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var iterationResult, iter, x;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([{ x = yield }] of [[{}]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(4);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 4);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-nested-obj-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-array-elem-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..d503e10ee170d1e28631ca6fa2e9e5b83d8ea74a
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-nested-obj-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-nested-obj-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 2;
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([{ x = yield }] of [[{}]]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-nested-obj.js b/test/language/statements/for-await-of/dstr-array-elem-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd47dba4fdd76c63512ed94510862c896fad6671
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-nested-obj.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-nested-obj.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([{ x }] of [[{ x: 2 }]]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-put-prop-ref-no-get.js b/test/language/statements/for-await-of/dstr-array-elem-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..6d1aad896f2fff98dab914929bad5724c5a2f7cb
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-put-prop-ref-no-get.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-put-prop-ref-no-get.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, setValue;
+x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([x.y] of [[23]]) {
+ assert.sameValue(setValue, 23);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-put-prop-ref.js b/test/language/statements/for-await-of/dstr-array-elem-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa72ff286bc7346280f1c20526536ce0685d20ae
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-put-prop-ref.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-put-prop-ref.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ([x.y] of [[4]]) {
+ assert.sameValue(x.y, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/dstr-array-elem-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..256dcb8869e828474add43478c5df05df53351a0
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-put-unresolvable-no-strict.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-put-unresolvable-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+var counter = 0;
+
+async function fn() {
+ for await ([ unresolvable ] of [[]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+assert.sameValue(unresolvable, undefined);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-target-identifier.js b/test/language/statements/for-await-of/dstr-array-elem-target-identifier.js
new file mode 100644
index 0000000000000000000000000000000000000000..f95b06dd558382a50d747184f994e403690b95c0
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-target-identifier.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-target-identifier.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, y, z;
+
+var counter = 0;
+
+async function fn() {
+ for await ([x, y, z] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, 2);
+ assert.sameValue(z, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-target-simple-no-strict.js b/test/language/statements/for-await-of/dstr-array-elem-target-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a9990e0a3c082ed128698d032d4c62a3649ef18
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-target-simple-no-strict.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-target-simple-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Identifiers that appear as the DestructuringAssignmentTarget in an AssignmentElement should take on the iterated value corresponding to their position in the ArrayAssignmentPattern. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var argument, eval;
+
+var counter = 0;
+
+async function fn() {
+ for await ([arguments, eval] of [[2, 3]]) {
+ assert.sameValue(arguments, 2);
+ assert.sameValue(eval, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-target-yield-expr.js b/test/language/statements/for-await-of/dstr-array-elem-target-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..f21bf7f7cb80838462f8c346a02839f92b573314
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-target-yield-expr.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-target-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement within a generator function body, it behaves as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var value = [33];
+var x = {};
+var iterationResult, iter;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x[yield] ] of [[33]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 33);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-target-yield-valid.js b/test/language/statements/for-await-of/dstr-array-elem-target-yield-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9b16fdff3703a58b5a288480624652a2646f678
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-target-yield-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-target-yield-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement outside of a generator function body, it behaves as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 'prop';
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x[yield] ] of [[33]]) {
+ assert.sameValue(x.prop, 33);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-elision-iter-nrml-close-skip.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-elision-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc73b88d0502e87471aaa8dace61716ab330f6ed
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-elision-iter-nrml-close-skip.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-elision-iter-nrml-close-skip.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose not invoked when elision exhausts the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+ [...]
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ 9. Return Completion(status).
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var iterable = {};
+var x;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+
+ return { done: nextCount > 1 };
+ },
+ return: function() {
+ returnCount += 1;
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , , ] of [iterable]) {
+ assert.sameValue(nextCount, 2);
+ assert.sameValue(returnCount, 0);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-elision-iter-nrml-close.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-elision-iter-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..9170bb3200e2fd01e8bcd252083bc8d9cbb73739
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-elision-iter-nrml-close.js
@@ -0,0 +1,87 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-elision-iter-nrml-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose invoked when elision does not exhaust the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 6. If Elision is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of Elision with
+ iteratorRecord as the argument.
+ b. If status is an abrupt completion, then
+ [...]
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var x;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , , ] of [iterable]) {
+ assert.sameValue(nextCount, 2);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-nrml-close-skip.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..be57dfb781200f3eead3cc04160f106c1989b9e0
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-nrml-close-skip.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-list-nrml-close-skip.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is not invoked when evaluation of AssignmentElementList exhausts the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 3. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 4. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 5. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var iterable = {};
+var thrower = function() {
+ throw new Test262Error();
+};
+var x;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return: function() {
+ returnCount += 1;
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-nrml-close.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d98bc175853b504eda5be4160a207cfcb0df82c
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-nrml-close.js
@@ -0,0 +1,86 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-list-nrml-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is invoked when evaluation of AssignmentElementList completes without exhausting the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 3. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 4. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 5. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var x;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close-err.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7b14a42999611c835a2f0701bc995a9203f33f3
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close-err.js
@@ -0,0 +1,86 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-list-rtrn-close-err.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is invoked when evaluation of AssignmentElementList returns a "return" completion and the iterator has not been marked as "done" (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 3. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 4. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 5. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var returnCount = 0;
+var unreachable = 0;
+var iterable = {};
+var iterator = {
+ return: function() {
+ returnCount += 1;
+
+ throw new Test262Error();
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ {}[yield] , ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+assert.throws(Test262Error, function() {
+ iter.return();
+});
+
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close-null.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..bbabb3d867278ffedf7a770814435a6b165b2452
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close-null.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-list-rtrn-close-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 3. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 4. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 5. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+ 9. If Type(innerResult.[[value]]) is not Object, throw a TypeError
+ exception.
+
+---*/
+var iterable = {};
+var iterator = {
+ return: function() {
+ return null;
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ {}[yield] , ] of [iterable]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+
+assert.throws(TypeError, function() {
+ iter.return();
+});
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cab9a05b4b7fe47e9a41da15b57ce5c2e3083bf
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-list-rtrn-close.js
@@ -0,0 +1,94 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-list-rtrn-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is invoked when evaluation of AssignmentElementList returns a "return" completion and the iterator has not been marked as "done" (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 3. Let iteratorRecord be Record {[[iterator]]: iterator, [[done]]: false}.
+ 4. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentElementList using
+ iteratorRecord as the argument.
+ 5. If status is an abrupt completion, then
+ a. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ b. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var returnCount = 0;
+var unreachable = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var iterator = {
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+var iter, result;
+
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ {}[yield] , ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+};
+
+iter = g();
+iter.next();
+result = iter.return(888);
+
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
+assert.sameValue(result.value, 888);
+assert(result.done, 'Iterator correctly closed');
+assert.sameValue(thisValue, iterator, 'correct `this` value');
+assert(!!args, 'arguments object provided');
+assert.sameValue(args.length, 0, 'zero arguments specified');
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-nrml-close-skip.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..c49c8b063a76ac25daeba3defac2b74b1029dab9
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-nrml-close-skip.js
@@ -0,0 +1,73 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-rest-nrml-close-skip.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is not called when rest element evaluation has exhausted the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 7. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ 9. Return Completion(status).
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var iterable = {};
+var x, y;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ return { value: nextCount, done: nextCount > 1 };
+ },
+ return: function() {
+ returnCount += 1;
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , ...y ] of [iterable]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+assert.sameValue(nextCount, 2, 'nextCount');
+assert.sameValue(returnCount, 0, 'returnCount');
+assert.sameValue(x, 1, 'x');
+assert.sameValue(y.length, 0, 'y.length');
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close-err.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..566e1a75ce88e6e2399f1e0771e9dadcdb51c40d
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close-err.js
@@ -0,0 +1,95 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-rest-rtrn-close-err.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when AssignmentRestEvaluation produces a "return" completion due to reference evaluation (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 7. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ 9. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var unreachable = 0;
+var x;
+var iterable = {};
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return: function() {
+ returnCount += 1;
+
+ throw new Test262Error();
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , ...{}[yield] ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+
+assert.throws(Test262Error, function() {
+ iter.return();
+});
+
+assert.sameValue(nextCount, 1);
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close-null.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..073175cf133091d495baf9eda5743e5806109d57
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close-null.js
@@ -0,0 +1,90 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-rest-rtrn-close-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 7. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ 9. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var nextCount = 0;
+var iterable = {};
+var x;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return: function() {
+ return null;
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , ...{}[yield] ] of [iterable]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+
+assert.throws(TypeError, function() {
+ iter.return();
+});
+
+assert.sameValue(nextCount, 1);
diff --git a/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close.js b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..188453533c08318bde49437c19e3f0bf6be51f77
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elem-trlg-iter-rest-rtrn-close.js
@@ -0,0 +1,101 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elem-trlg-iter-rest-rtrn-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when AssignmentRestEvaluation produces a "return" completion due to reference evaluation (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern :
+ [ AssignmentElementList , Elisionopt AssignmentRestElementopt ]
+
+ [...]
+ 7. If AssignmentRestElement is present, then
+ a. Let status be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement
+ with iteratorRecord as the argument.
+ 8. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ status).
+ 9. Return Completion(status).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var unreachable = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var x;
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+var iter, result;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([ x , ...{}[yield] ] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+result = iter.return(999);
+
+assert.sameValue(nextCount, 1);
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
+assert.sameValue(result.value, 999);
+assert(result.done, 'Iterator correctly closed');
+assert.sameValue(thisValue, iterator, 'correct `this` value');
+assert(!!args, 'arguments object provided');
+assert.sameValue(args.length, 0, 'zero arguments specified');
diff --git a/test/language/statements/for-await-of/dstr-array-elision-iter-nrml-close-skip.js b/test/language/statements/for-await-of/dstr-array-elision-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..a2d2ec0139362bb3b945219815ae698e13a70194
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elision-iter-nrml-close-skip.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elision-iter-nrml-close-skip.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is not called when iteration has exhausted the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elision ]
+
+ 1. Let iterator be GetIterator(value).
+ [...]
+ 5. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+ [...]
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var iterable = {};
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return: function() {
+ returnCount += 1;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elision-iter-nrml-close.js b/test/language/statements/for-await-of/dstr-array-elision-iter-nrml-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..509a6001c2646f3e95c5787126d22a5c2be77fbe
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elision-iter-nrml-close.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elision-iter-nrml-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when assignment evaluation has not exhausted the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elision ]
+
+ 1. Let iterator be GetIterator(value).
+ [...]
+ 5. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+ [...]
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ // Set an upper-bound to limit unnecessary iteration in non-conformant
+ // implementations
+ return { done: nextCount > 10 };
+ },
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ , ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elision-val-array.js b/test/language/statements/for-await-of/dstr-array-elision-val-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d55d53877eef745f029c48193c23e651bb16be9
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elision-val-array.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elision-val-array.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ArrayAssignmentPattern containing only Elisions requires iterable values (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ([,] of [[]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-elision-val-string.js b/test/language/statements/for-await-of/dstr-array-elision-val-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..ec09b914e552f48392a2e2928d2c9fc8e1541a36
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-elision-val-string.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-elision-val-string.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ArrayAssignmentPattern containing only Elisions requires iterable values (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ([,] of ['string literal']) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-empty-iter-close.js b/test/language/statements/for-await-of/dstr-array-empty-iter-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6bf46b8ca051799d745e45a15001f7d8f5cafb7
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-empty-iter-close.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-empty-iter-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Iterator is closed without iterating (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ ]
+
+ 1. Let iterator be GetIterator(value).
+ 2. ReturnIfAbrupt(iterator).
+ 3. Return IteratorClose(iterator, NormalCompletion(empty)).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([] of [iterable]) {
+ assert.sameValue(nextCount, 0);
+ assert.sameValue(returnCount, 1);
+ assert.sameValue(thisValue, iterator, 'correct `this` value');
+ assert(!!args, 'arguments object provided');
+ assert.sameValue(args.length, 0, 'zero arguments specified');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-empty-val-array.js b/test/language/statements/for-await-of/dstr-array-empty-val-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..897d5c7e253e7ab6edbc5a10cc3ca36953c00ffd
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-empty-val-array.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-empty-val-array.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ArrayAssignmentPattern without an AssignmentElementList requires iterable values. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ([] of [[]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-empty-val-string.js b/test/language/statements/for-await-of/dstr-array-empty-val-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..265d0f8984d8058db10bb2c8207eee73d108b3af
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-empty-val-string.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-empty-val-string.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ArrayAssignmentPattern without an AssignmentElementList requires iterable values. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ([] of ['string literal']) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-iteration.js b/test/language/statements/for-await-of/dstr-array-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..4552d7a751d2910a728893f95fc37c0bf11f7b89
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-iteration.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-iteration.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Value iteration only proceeds for the number of elements in the ArrayAssignmentPattern. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var count = 0;
+var g = function*() {
+ count += 1;
+ yield;
+ count += 1;
+ yield;
+ count += 1;
+}
+
+var counter = 0;
+
+async function fn() {
+ for await ([,,] of [g()]) {
+ assert.sameValue(count, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-after-element.js b/test/language/statements/for-await-of/dstr-array-rest-after-element.js
new file mode 100644
index 0000000000000000000000000000000000000000..d796a4d1d57355e9d9d0d7ea40ce17f8c77e5472
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-after-element.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-after-element.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An AssignmentRestElement following an AssignmentElement consumes all remaining iterable values. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ([x, ...y] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y.length, 2);
+ assert.sameValue(y[0], 2);
+ assert.sameValue(y[1], 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-after-elision.js b/test/language/statements/for-await-of/dstr-array-rest-after-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..c87534c5e8226831ff59a058da01b354dd47f0e5
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-after-elision.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-after-elision.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An AssignmentRestElement following an elision consumes all remaining iterable values. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([, ...x] of [[1, 2, 3]]) {
+ assert.sameValue(x.length, 2);
+ assert.sameValue(x[0], 2);
+ assert.sameValue(x[1], 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-elision.js b/test/language/statements/for-await-of/dstr-array-rest-elision.js
new file mode 100644
index 0000000000000000000000000000000000000000..af6b84134789df0579c81f5f9eee3dacb483b284
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-elision.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-elision.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: ArrayAssignmentPattern may include elisions at any position preceeding a AssignmentRestElement in a AssignmentElementList. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ([, , x, , ...y] of [[1, 2, 3, 4, 5, 6]]) {
+ assert.sameValue(x, 3);
+ assert.sameValue(y.length, 2);
+ assert.sameValue(y[0], 5);
+ assert.sameValue(y[1], 6);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-iter-nrml-close-skip.js b/test/language/statements/for-await-of/dstr-array-rest-iter-nrml-close-skip.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0f24a7fd91ff564a93bce2ce047a4e10f059d42
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-iter-nrml-close-skip.js
@@ -0,0 +1,67 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-iter-nrml-close-skip.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is not called when assignment evaluation has exhausted the iterator (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 5. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with
+ iteratorRecord as the argument
+ 6. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+ 7. Return result.
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var x;
+var iterable = {};
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return: function() {
+ returnCount += 1;
+ }
+};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([ ...x ] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close-err.js b/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close-err.js
new file mode 100644
index 0000000000000000000000000000000000000000..cfa8e8f4d2e20c87a9e4d794a282f44286cfe1ad
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close-err.js
@@ -0,0 +1,91 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-iter-rtrn-close-err.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when reference evaluation produces a "return" completion (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 5. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with
+ iteratorRecord as the argument
+ 6. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+
+ AssignmentRestElement[Yield] : ... DestructuringAssignmentTarget
+
+ 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an
+ ArrayLiteral, then
+ a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+ b. ReturnIfAbrupt(lref).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var returnCount = 0;
+var unreachable = 0;
+function ReturnError() {}
+var iterable = {};
+var iterator = {
+ return: function() {
+ returnCount += 1;
+
+ throw new Test262Error();
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{}[yield]] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+assert.throws(Test262Error, function() {
+ iter.return();
+});
+
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
diff --git a/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close-null.js b/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..becc03c060050b03d30aa04210ff2825809fe1a9
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close-null.js
@@ -0,0 +1,90 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-iter-rtrn-close-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose throws a TypeError when `return` returns a non-Object value (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 5. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with
+ iteratorRecord as the argument
+ 6. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+
+ AssignmentRestElement[Yield] : ... DestructuringAssignmentTarget
+
+ 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an
+ ArrayLiteral, then
+ a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+ b. ReturnIfAbrupt(lref).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var iterable = {};
+var iterator = {
+ return: function() {
+ return null;
+ }
+};
+var iter;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{}[yield]] of [iterable]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+
+assert.throws(TypeError, function() {
+ iter.return();
+});
diff --git a/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close.js b/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close.js
new file mode 100644
index 0000000000000000000000000000000000000000..fa4c16d68d14135d49dfebe0761342161be3ec3b
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-iter-rtrn-close.js
@@ -0,0 +1,102 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-iter-rtrn-close.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: IteratorClose is called when reference evaluation produces a "return" completion (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 5. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with
+ iteratorRecord as the argument
+ 6. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+
+ AssignmentRestElement[Yield] : ... DestructuringAssignmentTarget
+
+ 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an
+ ArrayLiteral, then
+ a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+ b. ReturnIfAbrupt(lref).
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ [...]
+
+ 7.4.6 IteratorClose( iterator, completion )
+
+ [...]
+ 6. Let innerResult be Call(return, iterator, « »).
+ 7. If completion.[[type]] is throw, return Completion(completion).
+ 8. If innerResult.[[type]] is throw, return Completion(innerResult).
+
+---*/
+var returnCount = 0;
+var unreachable = 0;
+var thisValue = null;
+var args = null;
+var iterable = {};
+var iterator = {
+ return: function() {
+ returnCount += 1;
+ thisValue = this;
+ args = arguments;
+ return {};
+ }
+};
+var iter, result;
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+function* g() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{}[yield]] of [iterable]) {
+ unreachable += 1;
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+iter = g();
+iter.next();
+result = iter.return(444);
+
+assert.sameValue(returnCount, 1);
+assert.sameValue(unreachable, 0, 'Unreachable statement was not executed');
+assert.sameValue(result.value, 444);
+assert(result.done, 'Iterator correctly closed');
+assert.sameValue(thisValue, iterator, 'correct `this` value');
+assert(!!args, 'arguments object provided');
+assert.sameValue(args.length, 0, 'zero arguments specified');
diff --git a/test/language/statements/for-await-of/dstr-array-rest-iteration.js b/test/language/statements/for-await-of/dstr-array-rest-iteration.js
new file mode 100644
index 0000000000000000000000000000000000000000..76dd8bd84269557bfe33aa16f486c8c391a97bff
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-iteration.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-iteration.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: In the presense of an AssignmentRestElement, value iteration exhausts the iterable value; (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var count = 0;
+var g = function*() {
+ count += 1;
+ yield;
+ count += 1;
+ yield;
+ count += 1;
+}
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...x] of [g()]) {
+ assert.sameValue(count, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-lref.js b/test/language/statements/for-await-of/dstr-array-rest-lref.js
new file mode 100644
index 0000000000000000000000000000000000000000..774372e2dd8d07130bacf52149a2776778bb614d
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-lref.js
@@ -0,0 +1,76 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-lref.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Reference is evaluated during assignment (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol.iterator, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ ArrayAssignmentPattern : [ Elisionopt AssignmentRestElement ]
+
+ [...]
+ 5. Let result be the result of performing
+ IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with
+ iteratorRecord as the argument
+ 6. If iteratorRecord.[[done]] is false, return IteratorClose(iterator,
+ result).
+
+ AssignmentRestElement[Yield] : ... DestructuringAssignmentTarget
+
+ 1. If DestructuringAssignmentTarget is neither an ObjectLiteral nor an
+ ArrayLiteral, then
+ a. Let lref be the result of evaluating DestructuringAssignmentTarget.
+ b. ReturnIfAbrupt(lref).
+ [...]
+
+---*/
+var nextCount = 0;
+var returnCount = 0;
+var iterable = {};
+var iterator = {
+ next: function() {
+ nextCount += 1;
+ return { done: true };
+ },
+ return: function() {
+ returnCount += 1;
+ }
+};
+var obj = {};
+iterable[Symbol.iterator] = function() {
+ return iterator;
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([...obj['a' + 'b']] of [iterable]) {
+ assert.sameValue(nextCount, 1);
+ assert.sameValue(returnCount, 0);
+ assert(!!obj.ab);
+ assert.sameValue(obj.ab.length, 0);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array-null.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..7e77f8f08d490fcf407dc48b0156a438823373bc
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array-null.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `null` as the only value, an array with a single `null` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x, y]] of [[null]]) {
+ assert.sameValue(x, null);
+ assert.sameValue(y, undefined);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined-hole.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..64475acd692c746b6965b03759d1e2e6542bbcf6
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined-hole.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array-undefined-hole.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is an array with a "hole", an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x]] of [[ , ]]) {
+ assert.sameValue(x, undefined);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined-own.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f7d3daad2ebcf95f8eba153b942f6cdcd8a9c23
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined-own.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array-undefined-own.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `undefined` as the only value, an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x]] of [[undefined]]) {
+ assert.sameValue(x, undefined);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b9e140806f313346e13d82ba41315f61ae13cdc
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array-undefined.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array-undefined.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is emits no values, an empty array should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x]] of [[]]) {
+ assert.sameValue(x, undefined);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array-yield-expr.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..80e9734a7b190b93441d5f4fcd359e4d22a5fb17
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array-yield-expr.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var value = [86];
+var x = {};
+var iterationResult, iter;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x[yield]]] of [[86]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 86);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..877c2b34eb53bb8e4b03ca401df7c3da8c2aa932
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 'prop';
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x[yield]]] of [[86]]) {
+ assert.sameValue(x.prop, 86);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-array.js b/test/language/statements/for-await-of/dstr-array-rest-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..08e0a641440c0d03b37ebffc7ada603baa945ec0
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-array.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-array.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...[x]] of [[1, 2, 3]]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj-null.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..353c891c703c3a1d74f08d4f137a6a5e4732893e
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-null.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal and the iterable emits `null` as the only value, an array with a single `null` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, length;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ 0: x, length }] of [[null]]) {
+ assert.sameValue(x, null);
+ assert.sameValue(length, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined-hole.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined-hole.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe597fa823a9e9cab359ec54f4694947ae5972bb
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined-hole.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj-undefined-hole.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable is an array with a "hole", an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ 0: x, length }] of [[ , ]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined-own.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined-own.js
new file mode 100644
index 0000000000000000000000000000000000000000..e75832cde021657cc15dd082b5a4a41e17fd2146
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined-own.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj-undefined-own.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal and the iterable emits `undefined` as the only value, an array with a single `undefined` element should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ 0: x, length }] of [[undefined]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..470a0ac3cd9cbced5dd79a7ec194870b6c3ac788
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-undefined.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj-undefined.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an obect literal and the iterable is emits no values, an empty array should be used as the value of the nested DestructuringAssignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+// Use the the top-level lexical scope for 'length' to provide compatibility with browsers
+// where length and name are properties of WindowProxy
+let length;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ 0: x, length }] of [[]]) {
+ assert.sameValue(x, undefined);
+ assert.sameValue(length, 0);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj-yield-expr.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..2be57590b489a057bfa0243855ab414929f901f6
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-yield-expr.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var iterationResult, iter, x;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ x = yield }] of [[{}]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(4);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 4);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2b21cfab52d4020ada55e817b996baa0f601e1b
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 2;
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ x = yield }] of [[{}]]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-nested-obj.js b/test/language/statements/for-await-of/dstr-array-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..4294b8c84fd4aa481c90d5487b0aa852437dabc8
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-nested-obj.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-nested-obj.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ([...{ 1: x }] of [[1, 2, 3]]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-put-prop-ref-no-get.js b/test/language/statements/for-await-of/dstr-array-rest-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..c705eae15eae4472b0c4d0b3c979712430fae7c4
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-put-prop-ref-no-get.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-put-prop-ref-no-get.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var setValue;
+var x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ([...x.y] of [[23, 45, 99]]) {
+ assert.sameValue(setValue.length, 3);
+ assert.sameValue(setValue[0], 23);
+ assert.sameValue(setValue[1], 45);
+ assert.sameValue(setValue[2], 99);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-put-prop-ref.js b/test/language/statements/for-await-of/dstr-array-rest-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fe4659dc68c250a196b82aac6f0d67d2a37c67c
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-put-prop-ref.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-put-prop-ref.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ([...x.y] of [[4, 3, 2]]) {
+ assert.sameValue(x.y.length, 3);
+ assert.sameValue(x.y[0], 4);
+ assert.sameValue(x.y[1], 3);
+ assert.sameValue(x.y[2], 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/dstr-array-rest-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e6ff5b606b6bf0ce9025f9ca7813f3619da73d5
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-put-unresolvable-no-strict.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-put-unresolvable-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+var counter = 0;
+
+async function fn() {
+ for await ([ ...unresolvable ] of [[]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+assert.sameValue(unresolvable.length, 0);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-yield-expr.js b/test/language/statements/for-await-of/dstr-array-rest-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..c43782995988359c741fbbd00bb897710575cdf8
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-yield-expr.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentRestElement and within the body of a generator function, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = {};
+var iterationResult, iter;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ([...x[yield]] of [[33, 44, 55]]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop.length, 3);
+assert.sameValue(x.prop[0], 33);
+assert.sameValue(x.prop[1], 44);
+assert.sameValue(x.prop[2], 55);
diff --git a/test/language/statements/for-await-of/dstr-array-rest-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-array-rest-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cb9d4ebed32b42dd819b2ce667ad4f20e36090b
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-array-rest-yield-ident-valid.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/array-rest-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentRestElement and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 'prop';
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ([...x[yield]] of [[33, 44, 55]]) {
+ assert.sameValue(x.prop.length, 3);
+ assert.sameValue(x.prop[0], 33);
+ assert.sameValue(x.prop[1], 44);
+ assert.sameValue(x.prop[2], 55);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-empty-bool.js b/test/language/statements/for-await-of/dstr-obj-empty-bool.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad785f19544b0b14538f708458e39b5a709821f6
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-empty-bool.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-empty-bool.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (boolean value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ({} of [false]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-empty-num.js b/test/language/statements/for-await-of/dstr-obj-empty-num.js
new file mode 100644
index 0000000000000000000000000000000000000000..bcf4e95a444b22640cc9cc938e6cc361db839b93
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-empty-num.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-empty-num.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (number value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ({} of [0]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-empty-obj.js b/test/language/statements/for-await-of/dstr-obj-empty-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c0db8e5fcdb8a424593231697f6eefe9650b270
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-empty-obj.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-empty-obj.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (object value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ({} of [{}]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-empty-string.js b/test/language/statements/for-await-of/dstr-obj-empty-string.js
new file mode 100644
index 0000000000000000000000000000000000000000..b4e26d6474926aa40b01ea7c7f98a6e2db75f4eb
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-empty-string.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-empty-string.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (string value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+
+var counter = 0;
+
+async function fn() {
+ for await ({} of ['']) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-empty-symbol.js b/test/language/statements/for-await-of/dstr-obj-empty-symbol.js
new file mode 100644
index 0000000000000000000000000000000000000000..a09130983c7f0456f443d8c4c9e762931a9cc635
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-empty-symbol.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-empty-symbol.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: An ObjectAssignmentPattern without an AssignmentPropertyList requires an object-coercible value (symbol value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [Symbol, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var s = Symbol();
+
+var counter = 0;
+
+async function fn() {
+ for await ({} of [s]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-first.js b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-first.js
new file mode 100644
index 0000000000000000000000000000000000000000..7830d74f61620358c72f048fcae0485d4e34a426
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-first.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-identifier-resolution-first.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (first of many) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+var y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x, y } of [{ x: 3 }]) {
+ assert.sameValue(x, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-last.js b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-last.js
new file mode 100644
index 0000000000000000000000000000000000000000..46abcb93711ea13bcfd5e9c20ead5c5e0ab2da99
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-last.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-identifier-resolution-last.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (last of many) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+var w;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ w, x } of [{ x: 4 }]) {
+ assert.sameValue(x, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-lone.js b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-lone.js
new file mode 100644
index 0000000000000000000000000000000000000000..dcce9d28d94a2b4b02fba2ea49969f7773a48e56
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-lone.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-identifier-resolution-lone.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone identifier) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x, } of [{ x: 2 }]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-middle.js b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-middle.js
new file mode 100644
index 0000000000000000000000000000000000000000..02ff3f7f5f5b00b871b0bd8f9c0d2a5e58f600da
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-middle.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-identifier-resolution-middle.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (within many) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+var w, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ w, x, y } of [{ x: 5 }]) {
+ assert.sameValue(x, 5);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-trlng.js b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-trlng.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc1dfdb3f0161694146960cd93f001fa1510a3c7
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-identifier-resolution-trlng.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-identifier-resolution-trlng.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone identifier with trailing comma) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x } of [{ x: 1 }]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-identifier-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-obj-id-identifier-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..cbbad6d53432786ed50c05c6b6a83d7f6c5e2a4f
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-identifier-yield-ident-valid.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-identifier-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: yield is a valid IdentifierReference in an AssignmentProperty outside of strict mode and generator functions. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ yield } of [{ yield: 3 }]) {
+ assert.sameValue(yield, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-assignment-missing.js b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-missing.js
new file mode 100644
index 0000000000000000000000000000000000000000..27be57883eea95938a46754ed7a0b89c38eeb907
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-missing.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-assignment-missing.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (no corresponding property defined). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = 1 } of [{}]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-assignment-null.js b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..fce306b29fe086a2a9d4f563adbd44e4d468d578
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-null.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-assignment-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (null property value defined). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = 1 } of [{ x: null }]) {
+ assert.sameValue(x, null);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-assignment-truthy.js b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-truthy.js
new file mode 100644
index 0000000000000000000000000000000000000000..4d64159d026ec40baa2fc85e8510311e5f1211dd
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-truthy.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-assignment-truthy.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (truthy property value defined). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = 1 } of [{ x: 2 }]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-assignment-undef.js b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d414449c17b6524fd0cd869972075b457065427
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-assignment-undef.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-assignment-undef.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference ("undefined" property value defined). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = 1 } of [{ x: undefined }]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-evaluation.js b/test/language/statements/for-await-of/dstr-obj-id-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f1c5dfbf4554c09f7c1c167b2e4f557c31d6034
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-evaluation.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-evaluation.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var flag1 = false;
+var flag2 = false;
+var x, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = flag1 = true, y = flag2 = true } of [{ y: 1 }]) {
+ assert.sameValue(flag1, true);
+ assert.sameValue(flag2, false);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-arrow.js b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..0905a9d9f99c7cbda9a2c17656763fae7b6ff68e
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-arrow.js
@@ -0,0 +1,53 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-fn-name-arrow.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+var arrow;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ arrow = () => {} } of [{}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-class.js b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac2b9629b6d7d4d5e0873ccf9a58575f9d1beb14
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-class.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-fn-name-class.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+var xCls, cls, xCls2;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ xCls = class x {}, cls = class {}, xCls2 = class { static name() {} } } of [{}]) {
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-cover.js b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8b5ffefbfebd7c1d729a9b148c782df0124ecae
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-cover.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-fn-name-cover.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+var xCover, cover;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ xCover = (0, function() {}), cover = (function() {}) } of [{}]) {
+ assert.notSameValue(xCover.name, 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-fn.js b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..52d6f587ae671369e45a10e4c6b76807418a00ff
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-fn.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-fn-name-fn.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+var xFn, fn;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ xFn = function x() {}, fn = function() {} } of [{}]) {
+ assert.notSameValue(xFn.name, 'xFn');
+
+ assert.sameValue(fn.name, 'fn');
+ verifyNotEnumerable(fn, 'name');
+ verifyNotWritable(fn, 'name');
+ verifyConfigurable(fn, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-gen.js b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..95ffac652f00e805dd90769a103e0e1b78a4af86
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-fn-name-gen.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-fn-name-gen.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentProperty : IdentifierReference Initializeropt
+ [...] 6. If Initializeropt 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, P).
+
+---*/
+var xGen, gen;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ xGen = function* x() {}, gen = function*() {} } of [{}]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-in.js b/test/language/statements/for-await-of/dstr-obj-id-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ccf0a61839b75e81d1fd2cfc764b9fd13be78f8
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-in.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-in.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The Initializer in an AssignmentProperty may be an `in` expression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var prop;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ prop = 'x' in {} } of [{}]) {
+ assert.sameValue(prop, false);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-order.js b/test/language/statements/for-await-of/dstr-obj-id-init-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..67b87e0f6d1dd2e45df8652082a6c8731367e450
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-order.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-order.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Initializer values should be assigned in left-to-right order. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = 0;
+var a, b;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ a = x += 1, b = x *= 2 } of [{}]) {
+ assert.sameValue(a, 1);
+ assert.sameValue(b, 2);
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-simple-no-strict.js b/test/language/statements/for-await-of/dstr-obj-id-init-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..159a1dc274486d1da829521defb8cc67e3940b51
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-simple-no-strict.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-simple-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var eval, arguments;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ eval = 3, arguments = 4 } of [{}]) {
+ assert.sameValue(eval, 3);
+ assert.sameValue(arguments, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-yield-expr.js b/test/language/statements/for-await-of/dstr-obj-id-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..bbe38946b1ebb4c0452d212eb99911c36179ebd4
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-yield-expr.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentProperty and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var iterationResult, x, iter;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = yield } of [{}]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(3);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 3);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-init-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-obj-id-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..b367dcca14f5e3f5d4ed809c856b3d85c054ebdb
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-init-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-init-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentProperty and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 3;
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x = yield } of [{}]) {
+ assert.sameValue(x, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-put-unresolvable-no-strict.js b/test/language/statements/for-await-of/dstr-obj-id-put-unresolvable-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..d385aa8367c6e7a9e1398881cba5204a56dea35c
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-put-unresolvable-no-strict.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-put-unresolvable-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+{
+
+var counter = 0;
+
+async function fn() {
+ for await ({ unresolvable } of [{}]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}
+
+assert.sameValue(unresolvable, undefined);
diff --git a/test/language/statements/for-await-of/dstr-obj-id-simple-no-strict.js b/test/language/statements/for-await-of/dstr-obj-id-simple-no-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f0f992cfaa1b066bcfe11c5472f1db5d1a6941a
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-id-simple-no-strict.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-id-simple-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var eval, arguments;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ eval, arguments } of [{ eval: 1, arguments: 2 }]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+assert.sameValue(eval, 1);
+assert.sameValue(arguments, 2);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-missing.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-missing.js
new file mode 100644
index 0000000000000000000000000000000000000000..6a87653fc709cd71cb0980e6dce673bfb3cd0bbc
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-missing.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-assignment-missing.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (non-existent property) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ y: x = 1 } of [{}]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-null.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-null.js
new file mode 100644
index 0000000000000000000000000000000000000000..c67bac5676f701d7f29946a2139c3cab6bfc9277
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-null.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-assignment-null.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is not undefined, the Initializer should be evaluated and the result assigned to the target reference (null value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ y: x = 1 } of [{ y: null }]) {
+ assert.sameValue(x, null);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-truthy.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-truthy.js
new file mode 100644
index 0000000000000000000000000000000000000000..66c39eb535d3242d7b447c7e420d8a41fcacefa1
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-truthy.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-assignment-truthy.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is not undefined, the Initializer should be evaluated and the result assigned to the target reference (truthy value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ y: x = 1 } of [{ y: 2 }]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-undef.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-undef.js
new file mode 100644
index 0000000000000000000000000000000000000000..0042c030a80ead6345f0c69618b3d12dcdf927d7
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-assignment-undef.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-assignment-undef.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the Initializer is present and v is undefined, the Initializer should be evaluated and the result assigned to the target reference (undefined value) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ y: x = 1 } of [{ y: undefined }]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-evaluation.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d70028902346c538b8c58217dece0bb530373d0
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-evaluation.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-evaluation.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The Initializer should only be evaluated if v is undefined. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var flag1 = false;
+var flag2 = false;
+var x, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: x = flag1 = true, y: y = flag2 = true } of [{ y: 1 }]) {
+ assert.sameValue(x, true, 'value of `x`');
+ assert.sameValue(flag1, true, 'value of `flag1`');
+ assert.sameValue(y, 1, 'value of `y`');
+ assert.sameValue(flag2, false, 'value of `flag2`');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-arrow.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-arrow.js
new file mode 100644
index 0000000000000000000000000000000000000000..ad7a8b454520a7818316cc17c789496fc7145d93
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-arrow.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-fn-name-arrow.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (ArrowFunction) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+ b. ReturnIfAbrupt(hasNameProperty).
+ c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+ GetReferencedName(lref)).
+
+---*/
+var arrow;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: arrow = () => {} } of [{}]) {
+ assert.sameValue(arrow.name, 'arrow');
+ verifyNotEnumerable(arrow, 'name');
+ verifyNotWritable(arrow, 'name');
+ verifyConfigurable(arrow, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-class.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-class.js
new file mode 100644
index 0000000000000000000000000000000000000000..d37d7ec7ce996b9b4ad5752bf04817231cd9f417
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-class.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-fn-name-class.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (ClassExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [class, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+ b. ReturnIfAbrupt(hasNameProperty).
+ c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+ GetReferencedName(lref)).
+
+---*/
+var xCls, cls, xCls2;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: xCls = class x {}, x: cls = class {}, x: xCls2 = class { static name() {} } } of [{}]) {
+ assert.notSameValue(xCls.name, 'xCls');
+ assert.notSameValue(xCls2.name, 'xCls2');
+
+ assert.sameValue(cls.name, 'cls');
+ verifyNotEnumerable(cls, 'name');
+ verifyNotWritable(cls, 'name');
+ verifyConfigurable(cls, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-cover.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-cover.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b3e3105f54f443a5d5f743f605bf57ed3772323
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-cover.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-fn-name-cover.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (CoverParenthesizedExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+ b. ReturnIfAbrupt(hasNameProperty).
+ c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+ GetReferencedName(lref)).
+
+---*/
+var xCover, cover;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: xCover = (0, function() {}), x: cover = (function() {}) } of [{}]) {
+ assert.notSameValue(xCover.name, 'xCover');
+
+ assert.sameValue(cover.name, 'cover');
+ verifyNotEnumerable(cover, 'name');
+ verifyNotWritable(cover, 'name');
+ verifyConfigurable(cover, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-fn.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-fn.js
new file mode 100644
index 0000000000000000000000000000000000000000..933a1146d55b29fcfca6bed52872e06057bbb7ef
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-fn.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-fn-name-fn.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (FunctionExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+ b. ReturnIfAbrupt(hasNameProperty).
+ c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+ GetReferencedName(lref)).
+
+---*/
+var xFn, fn;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: xFn = function x() {}, x: fn = function() {} } of [{}]) {
+ assert.notSameValue(xFn.name, 'xFn');
+
+ assert.sameValue(fn.name, 'fn');
+ verifyNotEnumerable(fn, 'name');
+ verifyNotWritable(fn, 'name');
+ verifyConfigurable(fn, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-gen.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-gen.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9ad13e0728f29906c9ec37061be5a2b6242a105
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-fn-name-gen.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-fn-name-gen.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Assignment of function `name` attribute (GeneratorExpression) (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+
+ AssignmentElement[Yield] : DestructuringAssignmentTarget Initializeropt
+ [...] 7. If Initializer is present and v is undefined and
+ IsAnonymousFunctionDefinition(Initializer) and IsIdentifierRef of
+ DestructuringAssignmentTarget are both true, then
+ a. Let hasNameProperty be HasOwnProperty(rhsValue, "name").
+ b. ReturnIfAbrupt(hasNameProperty).
+ c. If hasNameProperty is false, perform SetFunctionName(rhsValue,
+ GetReferencedName(lref)).
+
+---*/
+var xGen, gen;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: xGen = function* x() {}, x: gen = function*() {} } of [{}]) {
+ assert.notSameValue(xGen.name, 'xGen');
+
+ assert.sameValue(gen.name, 'gen');
+ verifyNotEnumerable(gen, 'name');
+ verifyNotWritable(gen, 'name');
+ verifyConfigurable(gen, 'name');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-in.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-in.js
new file mode 100644
index 0000000000000000000000000000000000000000..119402efa102ebcd8363f011d12e3bab6b269ea0
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-in.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-in.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The Initializer in an AssignmentElement may be an `in` expression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var prop;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: prop = 'x' in {} } of [{}]) {
+ assert.sameValue(prop, false);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-yield-expr.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..614793f4687cf6b7cef3e506ef764f07a57e7916
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-yield-expr.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var iterationResult, iter, x;
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: x = yield } of [{}]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(86);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 86);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-init-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..7b559b44b222dc60e405869d361be85d0a646211
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-init-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-init-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of an AssignmentElement and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 4;
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: x = yield } of [{}]) {
+ assert.sameValue(x, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-target-yield-expr.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-target-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..c281b74ed61ddc86bd897505a40828ca5a7faff2
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-target-yield-expr.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-target-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = {};
+var iterationResult, iter;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: x[yield] } of [{ x: 23 }]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x.prop, undefined);
+
+iterationResult = iter.next('prop');
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x.prop, 23);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-elem-target-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-obj-prop-elem-target-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..5670e4b7da5aa14cfda074d218f4148237d6bdc8
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-elem-target-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-elem-target-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the DestructuringAssignmentTarget of an AssignmentElement and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 'prop';
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: x[yield] } of [{ x: 23 }]) {
+ assert.sameValue(x.prop, 23);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-first.js b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-first.js
new file mode 100644
index 0000000000000000000000000000000000000000..75fd08237797f4cc21ae38fbb115fc77e727458e
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-first.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-identifier-resolution-first.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (first of many). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+var y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ a: x, y } of [{ a: 3 }]) {
+ assert.sameValue(x, 3);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-last.js b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-last.js
new file mode 100644
index 0000000000000000000000000000000000000000..31e0e54cccf916e684c0d2bc50902e2089dc5a97
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-last.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-identifier-resolution-last.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (last of many). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+var w;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ w, a: x } of [{ a: 4 }]) {
+ assert.sameValue(x, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-lone.js b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-lone.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a5b775121524591d4f0a841484d8fdb89e48266
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-lone.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-identifier-resolution-lone.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone element). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ a: x } of [{ a: 1 }]) {
+ assert.sameValue(x, 1);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-middle.js b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-middle.js
new file mode 100644
index 0000000000000000000000000000000000000000..827c0081f2579e10843934917b7d45ab20c2fc2a
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-middle.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-identifier-resolution-middle.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (within many). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+var w, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ w, a: x, y } of [{ a: 5 }]) {
+ assert.sameValue(x, 5);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-trlng.js b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-trlng.js
new file mode 100644
index 0000000000000000000000000000000000000000..34c9ed03a1c81e27a0eb98b198744bb7e53d0593
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-identifier-resolution-trlng.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-identifier-resolution-trlng.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Evaluation of DestructuringAssignmentTarget (lone element with trailing comma). (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = null;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ a: x, } of [{ a: 2 }]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-name-evaluation.js b/test/language/statements/for-await-of/dstr-obj-prop-name-evaluation.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ddb1000eb72a0b0af3af04f252e28fd6f9df696
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-name-evaluation.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-name-evaluation.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: PropertyName of an AssignmentProperty may be a ComputedPropertyName. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x, y, xy;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ ['x' + 'y']: x } of [{ x: 1, xy: 23, y: 2 }]) {
+ assert.sameValue(x, 23);
+ assert.sameValue(y, undefined);
+ assert.sameValue(xy, undefined);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-nested-array-yield-expr.js b/test/language/statements/for-await-of/dstr-obj-prop-nested-array-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..497cc6c313a4c23a1838d0c0d5f18a43ce28d938
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-nested-array-yield-expr.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-nested-array-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var iterationResult, iter, x;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: [x = yield] } of [{ x: [] }]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(24601);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 24601);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-nested-array-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-obj-prop-nested-array-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb7d3f4132ad9dd4d637534f8e86e835110c9889
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-nested-array-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-nested-array-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 22;
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: [x = yield] } of [{ x: [] }]) {
+ assert.sameValue(x, 22);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-nested-array.js b/test/language/statements/for-await-of/dstr-obj-prop-nested-array.js
new file mode 100644
index 0000000000000000000000000000000000000000..f1a26cb1a5bce5ac2a25a0d1a9c87bd26519b60b
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-nested-array.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-nested-array.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an array literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: [y] } of [{ x: [321] }]) {
+ assert.sameValue(y, 321);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-nested-obj-yield-expr.js b/test/language/statements/for-await-of/dstr-obj-prop-nested-obj-yield-expr.js
new file mode 100644
index 0000000000000000000000000000000000000000..9219d743c5896538953c547dfd91c37e6463e8f6
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-nested-obj-yield-expr.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-nested-obj-yield-expr.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and within a generator function body, it should behave as a YieldExpression. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [generators, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var iterationResult, iter, x = undefined;
+
+iter = (function*() {
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: { x = yield } } of [{ x: {} }]) {
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
+
+}());
+
+iterationResult = iter.next();
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, false);
+assert.sameValue(x, undefined);
+
+iterationResult = iter.next(4);
+
+assert.sameValue(iterationResult.value, undefined);
+assert.sameValue(iterationResult.done, true);
+assert.sameValue(x, 4);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-nested-obj-yield-ident-valid.js b/test/language/statements/for-await-of/dstr-obj-prop-nested-obj-yield-ident-valid.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7e0f638739623c71a5b548e9869cbcb6e6b413d
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-nested-obj-yield-ident-valid.js
@@ -0,0 +1,41 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-nested-obj-yield-ident-valid.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When a `yield` token appears within the Initializer of a nested destructuring assignment and outside of a generator function body, it should behave as an IdentifierReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var yield = 2;
+var result, x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: { x = yield } } of [{ x: {} }]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-nested-obj.js b/test/language/statements/for-await-of/dstr-obj-prop-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..55e6e14b4347bf954b1470658efc2c26f7c4147f
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-nested-obj.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-nested-obj.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var result, y;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x: { y } } of [{ x: { y: 2 } }]) {
+ assert.sameValue(y, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-put-order.js b/test/language/statements/for-await-of/dstr-obj-prop-put-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..0a48ac6b61b83543c35475087bddf5a5c7fff3a8
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-put-order.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-put-order.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The AssignmentElements in an AssignmentElementList are evaluated in left- to-right order. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ z: x, a: x } of [{ a: 2, z: 1 }]) {
+ assert.sameValue(x, 2);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-put-prop-ref-no-get.js b/test/language/statements/for-await-of/dstr-obj-prop-put-prop-ref-no-get.js
new file mode 100644
index 0000000000000000000000000000000000000000..04b04ad0286572dac1477ca7be98c8b228f917fa
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-put-prop-ref-no-get.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-put-prop-ref-no-get.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: If the DestructuringAssignmentTarget of an AssignmentElement is a PropertyReference, it should not be evaluated. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var setValue;
+var x = {
+ get y() {
+ $ERROR('The property should not be accessed.');
+ },
+ set y(val) {
+ setValue = val;
+ }
+};
+
+var counter = 0;
+
+async function fn() {
+ for await ({ a: x.y } of [{ a: 23 }]) {
+ assert.sameValue(setValue, 23);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-prop-put-prop-ref.js b/test/language/statements/for-await-of/dstr-obj-prop-put-prop-ref.js
new file mode 100644
index 0000000000000000000000000000000000000000..730e40577bcb74ae3ed59b4cacf511635c6ee730
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-prop-put-prop-ref.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-prop-put-prop-ref.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: The DestructuringAssignmentTarget of an AssignmentElement may be a PropertyReference. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ({ xy: x.y } of [{ xy: 4 }]) {
+ assert.sameValue(x.y, 4);
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/async-func-dstr-array-elem-put-unresolvable-no-strict-fn.js b/test/language/statements/for-await-of/dstr-obj-prop-put-unresolvable-no-strict.js
similarity index 80%
rename from test/language/statements/for-await-of/async-func-dstr-array-elem-put-unresolvable-no-strict-fn.js
rename to test/language/statements/for-await-of/dstr-obj-prop-put-unresolvable-no-strict.js
index 68f8f991698755cd5af0dd38360c2c61d528c796..d374794b4b01ba2de9cc2b19ffd7cceccdc68b7b 100644
--- a/test/language/statements/for-await-of/async-func-dstr-array-elem-put-unresolvable-no-strict-fn.js
+++ b/test/language/statements/for-await-of/dstr-obj-prop-put-unresolvable-no-strict.js
@@ -1,6 +1,6 @@
// This file was procedurally generated from the following sources:
-// - src/dstr-assignment-async-iteration/array-elem-put-unresolvable-no-strict-fn.case
-// - src/dstr-assignment-async-iteration/async-function/for-await-of-async-func.template
+// - src/dstr-assignment/obj-prop-put-unresolvable-no-strict.case
+// - src/dstr-assignment/default/for-await-of.template
/*---
description: Outside of strict mode, if the the assignment target is an unresolvable reference, a new `var` binding should be created in the environment record. (for-await-of statement)
esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
@@ -24,15 +24,21 @@ info: |
lhs using AssignmentPattern as the goal symbol.
[...]
---*/
+{
+
+var counter = 0;
-var iterCount = 0;
async function fn() {
- for await ([ unresolvable ] of [[]]) {
+ for await ({ x: unresolvable } of [{}]) {
- iterCount += 1;
+ counter += 1;
}
}
fn()
- .then(() => assert.sameValue(iterCount, 1, 'iteration occurred as expected'), $DONE)
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
.then($DONE, $DONE);
+
+}
+
+assert.sameValue(unresolvable, undefined);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-descriptors.js b/test/language/statements/for-await-of/dstr-obj-rest-descriptors.js
new file mode 100644
index 0000000000000000000000000000000000000000..5dcfe88c613c1a30dbb93efae761954b1d028c3a
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-descriptors.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-descriptors.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Object created from rest deconstruction doesn't copy source object property descriptors. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest;
+var obj = {};
+Object.defineProperty(obj, "a", { value: 3, configurable: false, enumerable: true });
+Object.defineProperty(obj, "b", { value: 4, writable: false, enumerable: true });
+
+var counter = 0;
+
+async function fn() {
+ for await ({...rest} of [obj]) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-empty-obj.js b/test/language/statements/for-await-of/dstr-obj-rest-empty-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb8351c3b9f10e7612abc1d4040108ec04a0f072
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-empty-obj.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-empty-obj.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: RestBindingInitialization creates a new object even if lhs is an empty object (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest;
+
+
+var counter = 0;
+
+async function fn() {
+ for await ({...rest} of [{}]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert.sameValue(typeof rest, "object");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-getter.js b/test/language/statements/for-await-of/dstr-obj-rest-getter.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c20d66a606a8a20e35bd606f3c19f2dbaa9d846
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-getter.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-getter.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Getter is called when obj is being deconstructed to a rest Object (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var x;
+var count = 0;
+
+var counter = 0;
+
+async function fn() {
+ for await ({...x} of [{ get v() { count++; return 2; } }]) {
+ assert.sameValue(x.v, 2);
+ assert.sameValue(count, 1);
+
+ verifyEnumerable(x, "v");
+ verifyWritable(x, "v");
+ verifyConfigurable(x, "v");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-nested-obj-nested-rest.js b/test/language/statements/for-await-of/dstr-obj-rest-nested-obj-nested-rest.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb5fbd358a4ffe33c6ed24c17828ebc7ca387a24
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-nested-obj-nested-rest.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-nested-obj-nested-rest.case
+// - src/dstr-assignment/default/for-await-of.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. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var a, b, c, rest;
+
+var counter = 0;
+
+async function fn() {
+ for await ({a, b, ...{c, ...rest}} of [{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");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-nested-obj.js b/test/language/statements/for-await-of/dstr-obj-rest-nested-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..54b86c9406abd4e783776f53cacdf51421a7e5ba
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-nested-obj.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-nested-obj.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object literal, it should be parsed parsed as a DestructuringAssignmentPattern and evaluated as a destructuring assignment. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var a, b, c, d, e;
+
+var counter = 0;
+
+async function fn() {
+ for await ({a, b, ...{c, e}} of [{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);
+ assert.sameValue(d, undefined);
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-number.js b/test/language/statements/for-await-of/dstr-obj-rest-number.js
new file mode 100644
index 0000000000000000000000000000000000000000..fcc93e86bd659fa2a1996b3694b0e0ea8ea513c1
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-number.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-number.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: RestBindingInitialization creates a new object even if lhs is a Number (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest;
+
+
+var counter = 0;
+
+async function fn() {
+ for await ({...rest} of [51]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert(rest instanceof Object);
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-obj-own-property.js b/test/language/statements/for-await-of/dstr-obj-rest-obj-own-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6e9b175551c78f529a6330df823dee7caef37ec
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-obj-own-property.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-obj-own-property.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Rest object contains just source object's own properties (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var o = Object.create({ x: 1, y: 2 });
+o.z = 3;
+
+var x, y, z;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x, ...{y , z} } of [o]) {
+ assert.sameValue(x, 1);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z, 3);
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-same-name.js b/test/language/statements/for-await-of/dstr-obj-rest-same-name.js
new file mode 100644
index 0000000000000000000000000000000000000000..63c531898d70e4e5f8c27966c6209bfdfa1ed505
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-same-name.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-same-name.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Proper setting in the values for rest name equal to a property name. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var o = {
+ x: 42,
+ y: 39,
+ z: 'cheeseburger'
+};
+
+var x, y, z;
+
+var counter = 0;
+
+async function fn() {
+ for await ({ x, ...z } of [o]) {
+ assert.sameValue(x, 42);
+ assert.sameValue(y, undefined);
+ assert.sameValue(z.y, 39);
+ assert.sameValue(z.z, 'cheeseburger');
+
+ var keys = Object.keys(z);
+ assert.sameValue(keys.length, 2);
+ assert.sameValue(keys[0], 'y');
+ assert.sameValue(keys[1], 'z');
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-skip-non-enumerable.js b/test/language/statements/for-await-of/dstr-obj-rest-skip-non-enumerable.js
new file mode 100644
index 0000000000000000000000000000000000000000..70f108e0d06cea8066d70b0ef0fc3ccd9d4f5826
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-skip-non-enumerable.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-skip-non-enumerable.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Rest object doesn't contain non-enumerable properties (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest;
+var obj = {a: 3, b: 4};
+Object.defineProperty(obj, "x", { value: 4, enumerable: false });
+
+var counter = 0;
+
+async function fn() {
+ for await ({...rest} of [obj]) {
+ assert.sameValue(rest.a, 3);
+ assert.sameValue(rest.b, 4);
+ assert.sameValue(Object.getOwnPropertyDescriptor(rest, "x"), undefined);
+
+ verifyEnumerable(rest, "a");
+ verifyWritable(rest, "a");
+ verifyConfigurable(rest, "a");
+
+ verifyEnumerable(rest, "b");
+ verifyWritable(rest, "b");
+ verifyConfigurable(rest, "b");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-str-val.js b/test/language/statements/for-await-of/dstr-obj-rest-str-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..be48d9b23946df64167d3c83da04af1ef5907b38
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-str-val.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-str-val.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: RestBindingInitialization creats an object with indexes as property name (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest;
+
+
+var counter = 0;
+
+async function fn() {
+ for await ({...rest} of ["foo"]) {
+ assert.sameValue(rest["0"], "f");
+ assert.sameValue(rest["1"], "o");
+ assert.sameValue(rest["2"], "o");
+ assert(rest instanceof Object);
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-symbol-val.js b/test/language/statements/for-await-of/dstr-obj-rest-symbol-val.js
new file mode 100644
index 0000000000000000000000000000000000000000..77b0e7fdf7547391a0fab8d6bd70602b78ded6c4
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-symbol-val.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-symbol-val.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: RestBindingInitialization creates a new object if lhs is a Symbol (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest;
+
+
+var counter = 0;
+
+async function fn() {
+ for await ({...rest} of [Symbol("foo")]) {
+ assert.notSameValue(rest, undefined);
+ assert.notSameValue(rest, null);
+ assert(rest instanceof Object);
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-to-property-with-setter.js b/test/language/statements/for-await-of/dstr-obj-rest-to-property-with-setter.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c28cb58050f924c225f8fed6aa3f952bc0f534c
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-to-property-with-setter.js
@@ -0,0 +1,51 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-to-property-with-setter.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object property setter, its value should be binded as rest object. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var settedValue;
+var executedGetter = false;
+var src = {
+ get y() { executedGetter = true; },
+ set y(v) {
+ settedValue = v;
+ }
+}
+src.y = undefined;
+
+var counter = 0;
+
+async function fn() {
+ for await ({...src.y} of [{ x: 1, y: 2}]) {
+ assert.sameValue(settedValue.x, 1);
+ assert.sameValue(settedValue.y, 2);
+ assert(!executedGetter, "The property should not be accessed");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-to-property.js b/test/language/statements/for-await-of/dstr-obj-rest-to-property.js
new file mode 100644
index 0000000000000000000000000000000000000000..3f8a1e9d87ebfa3c2c501b6bc2f0293dbc1fc192
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-to-property.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-to-property.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: When DestructuringAssignmentTarget is an object property, its value should be binded as rest object. (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var src = {};
+
+var counter = 0;
+
+async function fn() {
+ for await ({...src.y} of [{ x: 1, y: 2}]) {
+ assert.sameValue(src.y.x, 1);
+ assert.sameValue(src.y.y, 2);
+
+ verifyEnumerable(src, "y");
+ verifyWritable(src, "y");
+ verifyConfigurable(src, "y");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);
diff --git a/test/language/statements/for-await-of/dstr-obj-rest-valid-object.js b/test/language/statements/for-await-of/dstr-obj-rest-valid-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..5462f7fa22b64ba0e7be7923a20346c10cfbb1f3
--- /dev/null
+++ b/test/language/statements/for-await-of/dstr-obj-rest-valid-object.js
@@ -0,0 +1,54 @@
+// This file was procedurally generated from the following sources:
+// - src/dstr-assignment/obj-rest-valid-object.case
+// - src/dstr-assignment/default/for-await-of.template
+/*---
+description: Rest object contains just unextracted data (for-await-of statement)
+esid: sec-for-in-and-for-of-statements-runtime-semantics-labelledevaluation
+features: [object-rest, destructuring-binding, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ IterationStatement :
+ for await ( LeftHandSideExpression of AssignmentExpression ) Statement
+
+ 1. Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« »,
+ AssignmentExpression, iterate).
+ 2. Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement,
+ keyResult, assignment, labelSet).
+
+ 13.7.5.13 Runtime Semantics: ForIn/OfBodyEvaluation
+
+ [...]
+ 5. If destructuring is true and if lhsKind is assignment, then
+ a. Assert: lhs is a LeftHandSideExpression.
+ b. Let assignmentPattern be the parse of the source text corresponding to
+ lhs using AssignmentPattern as the goal symbol.
+ [...]
+---*/
+var rest, a, b;
+
+
+var counter = 0;
+
+async function fn() {
+ for await ({a, b, ...rest} of [{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");
+
+ counter += 1;
+ }
+}
+
+fn()
+ .then(() => assert.sameValue(counter, 1, 'iteration occurred as expected'), $DONE)
+ .then($DONE, $DONE);