From 69c1efd325deedf54db92a23008399e2b00fa51e Mon Sep 17 00:00:00 2001
From: Leo Balter <leonardo.balter@gmail.com>
Date: Mon, 5 Nov 2018 12:03:36 -0500
Subject: [PATCH] Generate tests
---
...after-same-line-gen-private-field-usage.js | 44 ++++++++++
...me-line-gen-private-method-getter-usage.js | 44 ++++++++++
...fter-same-line-gen-private-method-usage.js | 44 ++++++++++
...er-same-line-method-private-field-usage.js | 44 ++++++++++
...line-method-private-method-getter-usage.js | 44 ++++++++++
...r-same-line-method-private-method-usage.js | 44 ++++++++++
...ne-static-async-gen-private-field-usage.js | 58 ++++++++++++++
...c-async-gen-private-method-getter-usage.js | 58 ++++++++++++++
...e-static-async-gen-private-method-usage.js | 58 ++++++++++++++
...static-async-method-private-field-usage.js | 57 +++++++++++++
...sync-method-private-method-getter-usage.js | 57 +++++++++++++
...tatic-async-method-private-method-usage.js | 57 +++++++++++++
...ame-line-static-gen-private-field-usage.js | 44 ++++++++++
...-static-gen-private-method-getter-usage.js | 44 ++++++++++
...me-line-static-gen-private-method-usage.js | 44 ++++++++++
...-line-static-method-private-field-usage.js | 44 ++++++++++
...atic-method-private-method-getter-usage.js | 44 ++++++++++
...line-static-method-private-method-usage.js | 44 ++++++++++
...ultiple-definitions-private-field-usage.js | 80 +++++++++++++++++++
...definitions-private-method-getter-usage.js | 80 +++++++++++++++++++
...ltiple-definitions-private-method-usage.js | 80 +++++++++++++++++++
...stacked-definitions-private-field-usage.js | 58 ++++++++++++++
...definitions-private-method-getter-usage.js | 58 ++++++++++++++
...tacked-definitions-private-method-usage.js | 58 ++++++++++++++
...w-no-sc-line-method-private-field-usage.js | 45 +++++++++++
...line-method-private-method-getter-usage.js | 45 +++++++++++
...-no-sc-line-method-private-method-usage.js | 45 +++++++++++
...lds-new-sc-line-gen-private-field-usage.js | 45 +++++++++++
...sc-line-gen-private-method-getter-usage.js | 45 +++++++++++
...ds-new-sc-line-gen-private-method-usage.js | 45 +++++++++++
...-new-sc-line-method-private-field-usage.js | 45 +++++++++++
...line-method-private-method-getter-usage.js | 45 +++++++++++
...new-sc-line-method-private-method-usage.js | 45 +++++++++++
...regular-definitions-private-field-usage.js | 33 ++++++++
...definitions-private-method-getter-usage.js | 33 ++++++++
...egular-definitions-private-method-usage.js | 33 ++++++++
...same-line-async-gen-private-field-usage.js | 58 ++++++++++++++
...e-async-gen-private-method-getter-usage.js | 58 ++++++++++++++
...ame-line-async-gen-private-method-usage.js | 58 ++++++++++++++
...e-line-async-method-private-field-usage.js | 57 +++++++++++++
...sync-method-private-method-getter-usage.js | 57 +++++++++++++
...-line-async-method-private-method-usage.js | 57 +++++++++++++
...ields-same-line-gen-private-field-usage.js | 44 ++++++++++
...me-line-gen-private-method-getter-usage.js | 44 ++++++++++
...elds-same-line-gen-private-method-usage.js | 44 ++++++++++
...ds-same-line-method-private-field-usage.js | 44 ++++++++++
...line-method-private-method-getter-usage.js | 44 ++++++++++
...s-same-line-method-private-method-usage.js | 44 ++++++++++
...ields-wrapped-in-sc-private-field-usage.js | 35 ++++++++
...apped-in-sc-private-method-getter-usage.js | 35 ++++++++
...elds-wrapped-in-sc-private-method-usage.js | 35 ++++++++
...after-same-line-gen-private-field-usage.js | 44 ++++++++++
...me-line-gen-private-method-getter-usage.js | 44 ++++++++++
...fter-same-line-gen-private-method-usage.js | 44 ++++++++++
...er-same-line-method-private-field-usage.js | 44 ++++++++++
...line-method-private-method-getter-usage.js | 44 ++++++++++
...r-same-line-method-private-method-usage.js | 44 ++++++++++
...ne-static-async-gen-private-field-usage.js | 58 ++++++++++++++
...c-async-gen-private-method-getter-usage.js | 58 ++++++++++++++
...e-static-async-gen-private-method-usage.js | 58 ++++++++++++++
...static-async-method-private-field-usage.js | 57 +++++++++++++
...sync-method-private-method-getter-usage.js | 57 +++++++++++++
...tatic-async-method-private-method-usage.js | 57 +++++++++++++
...ame-line-static-gen-private-field-usage.js | 44 ++++++++++
...-static-gen-private-method-getter-usage.js | 44 ++++++++++
...me-line-static-gen-private-method-usage.js | 44 ++++++++++
...-line-static-method-private-field-usage.js | 44 ++++++++++
...atic-method-private-method-getter-usage.js | 44 ++++++++++
...line-static-method-private-method-usage.js | 44 ++++++++++
...ultiple-definitions-private-field-usage.js | 80 +++++++++++++++++++
...definitions-private-method-getter-usage.js | 80 +++++++++++++++++++
...ltiple-definitions-private-method-usage.js | 80 +++++++++++++++++++
...stacked-definitions-private-field-usage.js | 58 ++++++++++++++
...definitions-private-method-getter-usage.js | 58 ++++++++++++++
...tacked-definitions-private-method-usage.js | 58 ++++++++++++++
...w-no-sc-line-method-private-field-usage.js | 45 +++++++++++
...line-method-private-method-getter-usage.js | 45 +++++++++++
...-no-sc-line-method-private-method-usage.js | 45 +++++++++++
...lds-new-sc-line-gen-private-field-usage.js | 45 +++++++++++
...sc-line-gen-private-method-getter-usage.js | 45 +++++++++++
...ds-new-sc-line-gen-private-method-usage.js | 45 +++++++++++
...-new-sc-line-method-private-field-usage.js | 45 +++++++++++
...line-method-private-method-getter-usage.js | 45 +++++++++++
...new-sc-line-method-private-method-usage.js | 45 +++++++++++
...regular-definitions-private-field-usage.js | 33 ++++++++
...definitions-private-method-getter-usage.js | 33 ++++++++
...egular-definitions-private-method-usage.js | 33 ++++++++
...same-line-async-gen-private-field-usage.js | 58 ++++++++++++++
...e-async-gen-private-method-getter-usage.js | 58 ++++++++++++++
...ame-line-async-gen-private-method-usage.js | 58 ++++++++++++++
...e-line-async-method-private-field-usage.js | 57 +++++++++++++
...sync-method-private-method-getter-usage.js | 57 +++++++++++++
...-line-async-method-private-method-usage.js | 57 +++++++++++++
...ields-same-line-gen-private-field-usage.js | 44 ++++++++++
...me-line-gen-private-method-getter-usage.js | 44 ++++++++++
...elds-same-line-gen-private-method-usage.js | 44 ++++++++++
...ds-same-line-method-private-field-usage.js | 44 ++++++++++
...line-method-private-method-getter-usage.js | 44 ++++++++++
...s-same-line-method-private-method-usage.js | 44 ++++++++++
...ields-wrapped-in-sc-private-field-usage.js | 35 ++++++++
...apped-in-sc-private-method-getter-usage.js | 35 ++++++++
...elds-wrapped-in-sc-private-method-usage.js | 35 ++++++++
102 files changed, 5010 insertions(+)
create mode 100644 test/language/expressions/class/fields-after-same-line-gen-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-gen-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-gen-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-async-gen-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-async-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-async-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-async-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-gen-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-gen-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-gen-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-after-same-line-static-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-multiple-definitions-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-multiple-definitions-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-multiple-definitions-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-multiple-stacked-definitions-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-multiple-stacked-definitions-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-multiple-stacked-definitions-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-new-no-sc-line-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-new-no-sc-line-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-new-no-sc-line-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-new-sc-line-gen-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-new-sc-line-gen-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-new-sc-line-gen-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-new-sc-line-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-new-sc-line-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-new-sc-line-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-regular-definitions-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-regular-definitions-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-regular-definitions-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-async-gen-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-async-gen-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-async-gen-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-async-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-async-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-async-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-gen-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-gen-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-gen-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-method-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-method-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-same-line-method-private-method-usage.js
create mode 100644 test/language/expressions/class/fields-wrapped-in-sc-private-field-usage.js
create mode 100644 test/language/expressions/class/fields-wrapped-in-sc-private-method-getter-usage.js
create mode 100644 test/language/expressions/class/fields-wrapped-in-sc-private-method-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-gen-private-field-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-gen-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-gen-private-method-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-async-gen-private-field-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-async-gen-private-method-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-async-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-async-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-async-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-gen-private-field-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-gen-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-gen-private-method-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-after-same-line-static-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-multiple-definitions-private-field-usage.js
create mode 100644 test/language/statements/class/fields-multiple-definitions-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-multiple-definitions-private-method-usage.js
create mode 100644 test/language/statements/class/fields-multiple-stacked-definitions-private-field-usage.js
create mode 100644 test/language/statements/class/fields-multiple-stacked-definitions-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-multiple-stacked-definitions-private-method-usage.js
create mode 100644 test/language/statements/class/fields-new-no-sc-line-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-new-no-sc-line-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-new-no-sc-line-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-new-sc-line-gen-private-field-usage.js
create mode 100644 test/language/statements/class/fields-new-sc-line-gen-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-new-sc-line-gen-private-method-usage.js
create mode 100644 test/language/statements/class/fields-new-sc-line-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-new-sc-line-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-new-sc-line-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-regular-definitions-private-field-usage.js
create mode 100644 test/language/statements/class/fields-regular-definitions-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-regular-definitions-private-method-usage.js
create mode 100644 test/language/statements/class/fields-same-line-async-gen-private-field-usage.js
create mode 100644 test/language/statements/class/fields-same-line-async-gen-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-same-line-async-gen-private-method-usage.js
create mode 100644 test/language/statements/class/fields-same-line-async-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-same-line-async-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-same-line-async-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-same-line-gen-private-field-usage.js
create mode 100644 test/language/statements/class/fields-same-line-gen-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-same-line-gen-private-method-usage.js
create mode 100644 test/language/statements/class/fields-same-line-method-private-field-usage.js
create mode 100644 test/language/statements/class/fields-same-line-method-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-same-line-method-private-method-usage.js
create mode 100644 test/language/statements/class/fields-wrapped-in-sc-private-field-usage.js
create mode 100644 test/language/statements/class/fields-wrapped-in-sc-private-method-getter-usage.js
create mode 100644 test/language/statements/class/fields-wrapped-in-sc-private-method-usage.js
diff --git a/test/language/expressions/class/fields-after-same-line-gen-private-field-usage.js b/test/language/expressions/class/fields-after-same-line-gen-private-field-usage.js
new file mode 100644
index 0000000000..4742927529
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-gen-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-gen-private-method-getter-usage.js b/test/language/expressions/class/fields-after-same-line-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..2ead1b9cc3
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-gen-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-gen-private-method-usage.js b/test/language/expressions/class/fields-after-same-line-gen-private-method-usage.js
new file mode 100644
index 0000000000..ad5d834630
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-gen-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-method-private-field-usage.js b/test/language/expressions/class/fields-after-same-line-method-private-field-usage.js
new file mode 100644
index 0000000000..17250a9e45
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-method-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-method-private-method-getter-usage.js b/test/language/expressions/class/fields-after-same-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..a4e00ac7a2
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-method-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-method-private-method-usage.js b/test/language/expressions/class/fields-after-same-line-method-private-method-usage.js
new file mode 100644
index 0000000000..e60547415e
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-method-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-private-field-usage.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-field-usage.js
new file mode 100644
index 0000000000..674c0be5aa
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-field-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static async *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..a7df71df15
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-async-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static async *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-usage.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-usage.js
new file mode 100644
index 0000000000..475a97cb92
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-method-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static async *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-private-field-usage.js b/test/language/expressions/class/fields-after-same-line-static-async-method-private-field-usage.js
new file mode 100644
index 0000000000..58ce3febaa
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-private-field-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-async-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static async m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-private-method-getter-usage.js b/test/language/expressions/class/fields-after-same-line-static-async-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..f5cc497556
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-private-method-getter-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-async-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static async m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-private-method-usage.js b/test/language/expressions/class/fields-after-same-line-static-async-method-private-method-usage.js
new file mode 100644
index 0000000000..265c7f64c2
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-private-method-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-async-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static async m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-private-field-usage.js b/test/language/expressions/class/fields-after-same-line-static-gen-private-field-usage.js
new file mode 100644
index 0000000000..9096df38bb
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-private-method-getter-usage.js b/test/language/expressions/class/fields-after-same-line-static-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..14b6edc253
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-private-method-usage.js b/test/language/expressions/class/fields-after-same-line-static-gen-private-method-usage.js
new file mode 100644
index 0000000000..c463f976b8
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-private-field-usage.js b/test/language/expressions/class/fields-after-same-line-static-method-private-field-usage.js
new file mode 100644
index 0000000000..50d87159ad
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-method-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-private-method-getter-usage.js b/test/language/expressions/class/fields-after-same-line-static-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..4138350713
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-method-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-private-method-usage.js b/test/language/expressions/class/fields-after-same-line-static-method-private-method-usage.js
new file mode 100644
index 0000000000..034d7a6952
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-method-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-static-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ static m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-multiple-definitions-private-field-usage.js b/test/language/expressions/class/fields-multiple-definitions-private-field-usage.js
new file mode 100644
index 0000000000..5ce6c6f863
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-definitions-private-field-usage.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-multiple-definitions.template
+/*---
+description: PrivateName CallExpression usage (private field) (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ foo = "foobar";
+ m() { return 42 }
+ #m = 'test262';
+ m2() { return 39 }
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.m2(), 39);
+assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert.sameValue(c.m2, C.prototype.m2);
+
+verifyProperty(C.prototype, "m2", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-multiple-definitions-private-method-getter-usage.js b/test/language/expressions/class/fields-multiple-definitions-private-method-getter-usage.js
new file mode 100644
index 0000000000..ac03635126
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-definitions-private-method-getter-usage.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-multiple-definitions.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ foo = "foobar";
+ m() { return 42 }
+ get #m() { return 'test262'; }
+ m2() { return 39 }
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.m2(), 39);
+assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert.sameValue(c.m2, C.prototype.m2);
+
+verifyProperty(C.prototype, "m2", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-multiple-definitions-private-method-usage.js b/test/language/expressions/class/fields-multiple-definitions-private-method-usage.js
new file mode 100644
index 0000000000..7361c04493
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-definitions-private-method-usage.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-multiple-definitions.template
+/*---
+description: PrivateName CallExpression usage (private method) (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ foo = "foobar";
+ m() { return 42 }
+ #m() { return 'test262'; }
+ m2() { return 39 }
+ bar = "barbaz";
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.m2(), 39);
+assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert.sameValue(c.m2, C.prototype.m2);
+
+verifyProperty(C.prototype, "m2", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-private-field-usage.js b/test/language/expressions/class/fields-multiple-stacked-definitions-private-field-usage.js
new file mode 100644
index 0000000000..0b62a2f913
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-private-field-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-multiple-stacked-definitions.template
+/*---
+description: PrivateName CallExpression usage (private field) (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';
+ foo = "foobar"
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-private-method-getter-usage.js b/test/language/expressions/class/fields-multiple-stacked-definitions-private-method-getter-usage.js
new file mode 100644
index 0000000000..cc4803d5d4
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-private-method-getter-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-multiple-stacked-definitions.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; }
+ foo = "foobar"
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-private-method-usage.js b/test/language/expressions/class/fields-multiple-stacked-definitions-private-method-usage.js
new file mode 100644
index 0000000000..f4f7fa08e7
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-private-method-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-multiple-stacked-definitions.template
+/*---
+description: PrivateName CallExpression usage (private method) (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; }
+ foo = "foobar"
+ bar = "barbaz";
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-private-field-usage.js b/test/language/expressions/class/fields-new-no-sc-line-method-private-field-usage.js
new file mode 100644
index 0000000000..4ff69dfb41
--- /dev/null
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-private-field-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-new-no-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-private-method-getter-usage.js b/test/language/expressions/class/fields-new-no-sc-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..d46583c67f
--- /dev/null
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-private-method-getter-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-new-no-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; }
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-private-method-usage.js b/test/language/expressions/class/fields-new-no-sc-line-method-private-method-usage.js
new file mode 100644
index 0000000000..45ee29a7d9
--- /dev/null
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-private-method-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-new-no-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; }
+ m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-private-field-usage.js b/test/language/expressions/class/fields-new-sc-line-gen-private-field-usage.js
new file mode 100644
index 0000000000..57ee8784d4
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-gen-private-field-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-new-sc-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';;
+ *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-private-method-getter-usage.js b/test/language/expressions/class/fields-new-sc-line-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..a89962a5bc
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-gen-private-method-getter-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-new-sc-line-generator.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; };
+ *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-private-method-usage.js b/test/language/expressions/class/fields-new-sc-line-gen-private-method-usage.js
new file mode 100644
index 0000000000..d27918c87d
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-gen-private-method-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-new-sc-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; };
+ *m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-sc-line-method-private-field-usage.js b/test/language/expressions/class/fields-new-sc-line-method-private-field-usage.js
new file mode 100644
index 0000000000..272a6a2f97
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-method-private-field-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-new-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';;
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-sc-line-method-private-method-getter-usage.js b/test/language/expressions/class/fields-new-sc-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..5f46aa8eb1
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-method-private-method-getter-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-new-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; };
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-new-sc-line-method-private-method-usage.js b/test/language/expressions/class/fields-new-sc-line-method-private-method-usage.js
new file mode 100644
index 0000000000..6ab38a019b
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-method-private-method-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-new-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; };
+ m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-regular-definitions-private-field-usage.js b/test/language/expressions/class/fields-regular-definitions-private-field-usage.js
new file mode 100644
index 0000000000..c4862fa0b8
--- /dev/null
+++ b/test/language/expressions/class/fields-regular-definitions-private-field-usage.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-regular-definitions.template
+/*---
+description: PrivateName CallExpression usage (private field) (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-regular-definitions-private-method-getter-usage.js b/test/language/expressions/class/fields-regular-definitions-private-method-getter-usage.js
new file mode 100644
index 0000000000..a4e5f79d2f
--- /dev/null
+++ b/test/language/expressions/class/fields-regular-definitions-private-method-getter-usage.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-regular-definitions.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-regular-definitions-private-method-usage.js b/test/language/expressions/class/fields-regular-definitions-private-method-usage.js
new file mode 100644
index 0000000000..39de61dc65
--- /dev/null
+++ b/test/language/expressions/class/fields-regular-definitions-private-method-usage.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-regular-definitions.template
+/*---
+description: PrivateName CallExpression usage (private method) (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-same-line-async-gen-private-field-usage.js b/test/language/expressions/class/fields-same-line-async-gen-private-field-usage.js
new file mode 100644
index 0000000000..f92c14b0b2
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-gen-private-field-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ async *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-private-method-getter-usage.js b/test/language/expressions/class/fields-same-line-async-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..b48d7ea9e8
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-gen-private-method-getter-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-async-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ async *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-private-method-usage.js b/test/language/expressions/class/fields-same-line-async-gen-private-method-usage.js
new file mode 100644
index 0000000000..500391d1b4
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-gen-private-method-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ async *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-private-field-usage.js b/test/language/expressions/class/fields-same-line-async-method-private-field-usage.js
new file mode 100644
index 0000000000..3ed0aa98c2
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-method-private-field-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-async-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ async m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-private-method-getter-usage.js b/test/language/expressions/class/fields-same-line-async-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..bb7da05ed9
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-method-private-method-getter-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-async-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ async m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-private-method-usage.js b/test/language/expressions/class/fields-same-line-async-method-private-method-usage.js
new file mode 100644
index 0000000000..384228b9c4
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-method-private-method-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-after-same-line-async-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ async m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-gen-private-field-usage.js b/test/language/expressions/class/fields-same-line-gen-private-field-usage.js
new file mode 100644
index 0000000000..a759c8cd62
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-gen-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-same-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';; *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-same-line-gen-private-method-getter-usage.js b/test/language/expressions/class/fields-same-line-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..7066d93742
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-gen-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-same-line-generator.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; }; *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-same-line-gen-private-method-usage.js b/test/language/expressions/class/fields-same-line-gen-private-method-usage.js
new file mode 100644
index 0000000000..cd280de1b2
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-gen-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-same-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; }; *m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-same-line-method-private-field-usage.js b/test/language/expressions/class/fields-same-line-method-private-field-usage.js
new file mode 100644
index 0000000000..4b37abf5cc
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-method-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m = 'test262';; m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-same-line-method-private-method-getter-usage.js b/test/language/expressions/class/fields-same-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..7b881f662d
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-method-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ get #m() { return 'test262'; }; m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-same-line-method-private-method-usage.js b/test/language/expressions/class/fields-same-line-method-private-method-usage.js
new file mode 100644
index 0000000000..d191c1c202
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-method-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ #m() { return 'test262'; }; m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-private-field-usage.js b/test/language/expressions/class/fields-wrapped-in-sc-private-field-usage.js
new file mode 100644
index 0000000000..db915bfc1f
--- /dev/null
+++ b/test/language/expressions/class/fields-wrapped-in-sc-private-field-usage.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-expr-wrapped-in-sc.template
+/*---
+description: PrivateName CallExpression usage (private field) (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ ;;;;
+ ;;;;;;#m = 'test262';;;;;;;;
+ ;;;;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-private-method-getter-usage.js b/test/language/expressions/class/fields-wrapped-in-sc-private-method-getter-usage.js
new file mode 100644
index 0000000000..a00e4e4a2d
--- /dev/null
+++ b/test/language/expressions/class/fields-wrapped-in-sc-private-method-getter-usage.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-expr-wrapped-in-sc.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ ;;;;
+ ;;;;;;get #m() { return 'test262'; };;;;;;;
+ ;;;;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-private-method-usage.js b/test/language/expressions/class/fields-wrapped-in-sc-private-method-usage.js
new file mode 100644
index 0000000000..4e7f680845
--- /dev/null
+++ b/test/language/expressions/class/fields-wrapped-in-sc-private-method-usage.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-expr-wrapped-in-sc.template
+/*---
+description: PrivateName CallExpression usage (private method) (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+var C = class {
+ ;;;;
+ ;;;;;;#m() { return 'test262'; };;;;;;;
+ ;;;;
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-gen-private-field-usage.js b/test/language/statements/class/fields-after-same-line-gen-private-field-usage.js
new file mode 100644
index 0000000000..e708f8e5ab
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-gen-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-gen-private-method-getter-usage.js b/test/language/statements/class/fields-after-same-line-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..85cab8b982
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-gen-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-gen-private-method-usage.js b/test/language/statements/class/fields-after-same-line-gen-private-method-usage.js
new file mode 100644
index 0000000000..3a33efb763
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-gen-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-method-private-field-usage.js b/test/language/statements/class/fields-after-same-line-method-private-field-usage.js
new file mode 100644
index 0000000000..d9bf5c5e45
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-method-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-method-private-method-getter-usage.js b/test/language/statements/class/fields-after-same-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..e9582f50f8
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-method-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-method-private-method-usage.js b/test/language/statements/class/fields-after-same-line-method-private-method-usage.js
new file mode 100644
index 0000000000..85544cd901
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-method-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-private-field-usage.js b/test/language/statements/class/fields-after-same-line-static-async-gen-private-field-usage.js
new file mode 100644
index 0000000000..6f6f5bead3
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-private-field-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static async *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js b/test/language/statements/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..714b52ada4
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-private-method-getter-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-async-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static async *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-private-method-usage.js b/test/language/statements/class/fields-after-same-line-static-async-gen-private-method-usage.js
new file mode 100644
index 0000000000..ece0a9c4f3
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-private-method-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static async *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-private-field-usage.js b/test/language/statements/class/fields-after-same-line-static-async-method-private-field-usage.js
new file mode 100644
index 0000000000..caff21d030
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-private-field-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-async-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static async m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-private-method-getter-usage.js b/test/language/statements/class/fields-after-same-line-static-async-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..3539344904
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-private-method-getter-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-async-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static async m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-private-method-usage.js b/test/language/statements/class/fields-after-same-line-static-async-method-private-method-usage.js
new file mode 100644
index 0000000000..775137afc4
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-private-method-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-async-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static async m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+C.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-private-field-usage.js b/test/language/statements/class/fields-after-same-line-static-gen-private-field-usage.js
new file mode 100644
index 0000000000..509fdf5cc2
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-gen-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-private-method-getter-usage.js b/test/language/statements/class/fields-after-same-line-static-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..6b36c0acb0
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-gen-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-private-method-usage.js b/test/language/statements/class/fields-after-same-line-static-gen-private-method-usage.js
new file mode 100644
index 0000000000..be5f38c9d8
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-gen-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m().next().value, 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-static-method-private-field-usage.js b/test/language/statements/class/fields-after-same-line-static-method-private-field-usage.js
new file mode 100644
index 0000000000..2c3c302b88
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-method-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-static-method-private-method-getter-usage.js b/test/language/statements/class/fields-after-same-line-static-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..dc7b878171
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-method-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-after-same-line-static-method-private-method-usage.js b/test/language/statements/class/fields-after-same-line-static-method-private-method-usage.js
new file mode 100644
index 0000000000..77e87bc92e
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-method-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-static-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ static m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(C.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+
+verifyProperty(C, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-multiple-definitions-private-field-usage.js b/test/language/statements/class/fields-multiple-definitions-private-field-usage.js
new file mode 100644
index 0000000000..1b5c3c5ef0
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-definitions-private-field-usage.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-multiple-definitions.template
+/*---
+description: PrivateName CallExpression usage (private field) (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ foo = "foobar";
+ m() { return 42 }
+ #m = 'test262';
+ m2() { return 39 }
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.m2(), 39);
+assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert.sameValue(c.m2, C.prototype.m2);
+
+verifyProperty(C.prototype, "m2", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-multiple-definitions-private-method-getter-usage.js b/test/language/statements/class/fields-multiple-definitions-private-method-getter-usage.js
new file mode 100644
index 0000000000..5d54af16c9
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-definitions-private-method-getter-usage.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-multiple-definitions.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ foo = "foobar";
+ m() { return 42 }
+ get #m() { return 'test262'; }
+ m2() { return 39 }
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.m2(), 39);
+assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert.sameValue(c.m2, C.prototype.m2);
+
+verifyProperty(C.prototype, "m2", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-multiple-definitions-private-method-usage.js b/test/language/statements/class/fields-multiple-definitions-private-method-usage.js
new file mode 100644
index 0000000000..5a8d9b3c85
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-definitions-private-method-usage.js
@@ -0,0 +1,80 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-multiple-definitions.template
+/*---
+description: PrivateName CallExpression usage (private method) (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ foo = "foobar";
+ m() { return 42 }
+ #m() { return 'test262'; }
+ m2() { return 39 }
+ bar = "barbaz";
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.m2(), 39);
+assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert.sameValue(c.m2, C.prototype.m2);
+
+verifyProperty(C.prototype, "m2", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-private-field-usage.js b/test/language/statements/class/fields-multiple-stacked-definitions-private-field-usage.js
new file mode 100644
index 0000000000..0780f2eefb
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-private-field-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-multiple-stacked-definitions.template
+/*---
+description: PrivateName CallExpression usage (private field) (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';
+ foo = "foobar"
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-private-method-getter-usage.js b/test/language/statements/class/fields-multiple-stacked-definitions-private-method-getter-usage.js
new file mode 100644
index 0000000000..f28fbe327b
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-private-method-getter-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-multiple-stacked-definitions.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; }
+ foo = "foobar"
+ bar = "barbaz";
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-private-method-usage.js b/test/language/statements/class/fields-multiple-stacked-definitions-private-method-usage.js
new file mode 100644
index 0000000000..bb45bff6db
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-private-method-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-multiple-stacked-definitions.template
+/*---
+description: PrivateName CallExpression usage (private method) (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; }
+ foo = "foobar"
+ bar = "barbaz";
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.foo, "foobar");
+assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+
+verifyProperty(c, "foo", {
+ value: "foobar",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.bar, "barbaz");
+assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+
+verifyProperty(c, "bar", {
+ value: "barbaz",
+ enumerable: true,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-private-field-usage.js b/test/language/statements/class/fields-new-no-sc-line-method-private-field-usage.js
new file mode 100644
index 0000000000..07721acc0a
--- /dev/null
+++ b/test/language/statements/class/fields-new-no-sc-line-method-private-field-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-new-no-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-private-method-getter-usage.js b/test/language/statements/class/fields-new-no-sc-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..06262bff41
--- /dev/null
+++ b/test/language/statements/class/fields-new-no-sc-line-method-private-method-getter-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-new-no-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; }
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-private-method-usage.js b/test/language/statements/class/fields-new-no-sc-line-method-private-method-usage.js
new file mode 100644
index 0000000000..4f0d61f109
--- /dev/null
+++ b/test/language/statements/class/fields-new-no-sc-line-method-private-method-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-new-no-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; }
+ m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-sc-line-gen-private-field-usage.js b/test/language/statements/class/fields-new-sc-line-gen-private-field-usage.js
new file mode 100644
index 0000000000..31cfb364c7
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-gen-private-field-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-new-sc-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';;
+ *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-sc-line-gen-private-method-getter-usage.js b/test/language/statements/class/fields-new-sc-line-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..298fedbbbb
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-gen-private-method-getter-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-new-sc-line-generator.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; };
+ *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-sc-line-gen-private-method-usage.js b/test/language/statements/class/fields-new-sc-line-gen-private-method-usage.js
new file mode 100644
index 0000000000..113c872428
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-gen-private-method-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-new-sc-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; };
+ *m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-sc-line-method-private-field-usage.js b/test/language/statements/class/fields-new-sc-line-method-private-field-usage.js
new file mode 100644
index 0000000000..187d73a77f
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-method-private-field-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-new-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';;
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-sc-line-method-private-method-getter-usage.js b/test/language/statements/class/fields-new-sc-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..5205cb4884
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-method-private-method-getter-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-new-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; };
+ m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-new-sc-line-method-private-method-usage.js b/test/language/statements/class/fields-new-sc-line-method-private-method-usage.js
new file mode 100644
index 0000000000..3a81e315d6
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-method-private-method-usage.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-new-sc-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; };
+ m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-regular-definitions-private-field-usage.js b/test/language/statements/class/fields-regular-definitions-private-field-usage.js
new file mode 100644
index 0000000000..56090a9ce1
--- /dev/null
+++ b/test/language/statements/class/fields-regular-definitions-private-field-usage.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-regular-definitions.template
+/*---
+description: PrivateName CallExpression usage (private field) (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-regular-definitions-private-method-getter-usage.js b/test/language/statements/class/fields-regular-definitions-private-method-getter-usage.js
new file mode 100644
index 0000000000..ed1c2a3710
--- /dev/null
+++ b/test/language/statements/class/fields-regular-definitions-private-method-getter-usage.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-regular-definitions.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-regular-definitions-private-method-usage.js b/test/language/statements/class/fields-regular-definitions-private-method-usage.js
new file mode 100644
index 0000000000..4d73110485
--- /dev/null
+++ b/test/language/statements/class/fields-regular-definitions-private-method-usage.js
@@ -0,0 +1,33 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-regular-definitions.template
+/*---
+description: PrivateName CallExpression usage (private method) (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-same-line-async-gen-private-field-usage.js b/test/language/statements/class/fields-same-line-async-gen-private-field-usage.js
new file mode 100644
index 0000000000..2beb41b705
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-gen-private-field-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ async *m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-private-method-getter-usage.js b/test/language/statements/class/fields-same-line-async-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..10b4a2a8e5
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-gen-private-method-getter-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-async-gen.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ async *m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-private-method-usage.js b/test/language/statements/class/fields-same-line-async-gen-private-method-usage.js
new file mode 100644
index 0000000000..84afd6b90c
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-gen-private-method-usage.js
@@ -0,0 +1,58 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-async-gen.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ async *m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().next().then(function(v) {
+ assert.sameValue(v.value, 42);
+ assert.sameValue(v.done, true);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-private-field-usage.js b/test/language/statements/class/fields-same-line-async-method-private-field-usage.js
new file mode 100644
index 0000000000..6ed26ae663
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-method-private-field-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-async-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ async m() { return 42; } #m = 'test262';;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-private-method-getter-usage.js b/test/language/statements/class/fields-same-line-async-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..99888641be
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-method-private-method-getter-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-async-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ async m() { return 42; } get #m() { return 'test262'; };
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-private-method-usage.js b/test/language/statements/class/fields-same-line-async-method-private-method-usage.js
new file mode 100644
index 0000000000..36efc7daf3
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-method-private-method-usage.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-after-same-line-async-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ async m() { return 42; } #m() { return 'test262'; };
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert.sameValue(c.m, C.prototype.m);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+}, {restore: true});
+
+c.m().then(function(v) {
+ assert.sameValue(v, 42);
+
+ function assertions() {
+ // Cover $DONE handler for async cases.
+ function $DONE(error) {
+ if (error) {
+ throw new Test262Error('Test262:AsyncTestFailure')
+ }
+ }
+ assert.sameValue(c.method(), 'test262');
+ }
+
+ return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-gen-private-field-usage.js b/test/language/statements/class/fields-same-line-gen-private-field-usage.js
new file mode 100644
index 0000000000..59ce403db3
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-gen-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-same-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';; *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-same-line-gen-private-method-getter-usage.js b/test/language/statements/class/fields-same-line-gen-private-method-getter-usage.js
new file mode 100644
index 0000000000..e9c8ccbe39
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-gen-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-same-line-generator.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; }; *m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-same-line-gen-private-method-usage.js b/test/language/statements/class/fields-same-line-gen-private-method-usage.js
new file mode 100644
index 0000000000..4d8429cbf2
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-gen-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-same-line-generator.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public, generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; }; *m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m().next().value, 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-same-line-method-private-field-usage.js b/test/language/statements/class/fields-same-line-method-private-field-usage.js
new file mode 100644
index 0000000000..7c5bf42467
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-method-private-field-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private field) (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m = 'test262';; m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-same-line-method-private-method-getter-usage.js b/test/language/statements/class/fields-same-line-method-private-method-getter-usage.js
new file mode 100644
index 0000000000..fbf8eb4063
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-method-private-method-getter-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ get #m() { return 'test262'; }; m() { return 42; }
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-same-line-method-private-method-usage.js b/test/language/statements/class/fields-same-line-method-private-method-usage.js
new file mode 100644
index 0000000000..2eb883d8d3
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-method-private-method-usage.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-same-line-method.template
+/*---
+description: PrivateName CallExpression usage (private method) (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ #m() { return 'test262'; }; m() { return 42; }
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.m(), 42);
+assert.sameValue(c.m, C.prototype.m);
+assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+
+verifyProperty(C.prototype, "m", {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+});
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-wrapped-in-sc-private-field-usage.js b/test/language/statements/class/fields-wrapped-in-sc-private-field-usage.js
new file mode 100644
index 0000000000..aeee9ba532
--- /dev/null
+++ b/test/language/statements/class/fields-wrapped-in-sc-private-field-usage.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-field-usage.case
+// - src/class-elements/productions/cls-decl-wrapped-in-sc.template
+/*---
+description: PrivateName CallExpression usage (private field) (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ ;;;;
+ ;;;;;;#m = 'test262';;;;;;;;
+ ;;;;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-wrapped-in-sc-private-method-getter-usage.js b/test/language/statements/class/fields-wrapped-in-sc-private-method-getter-usage.js
new file mode 100644
index 0000000000..7b522c420b
--- /dev/null
+++ b/test/language/statements/class/fields-wrapped-in-sc-private-method-getter-usage.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-getter-usage.case
+// - src/class-elements/productions/cls-decl-wrapped-in-sc.template
+/*---
+description: PrivateName CallExpression usage (Accesor get method) (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ ;;;;
+ ;;;;;;get #m() { return 'test262'; };;;;;;;
+ ;;;;
+ method() {
+ return this.#m;
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
diff --git a/test/language/statements/class/fields-wrapped-in-sc-private-method-usage.js b/test/language/statements/class/fields-wrapped-in-sc-private-method-usage.js
new file mode 100644
index 0000000000..f003b1db45
--- /dev/null
+++ b/test/language/statements/class/fields-wrapped-in-sc-private-method-usage.js
@@ -0,0 +1,35 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/private-method-usage.case
+// - src/class-elements/productions/cls-decl-wrapped-in-sc.template
+/*---
+description: PrivateName CallExpression usage (private method) (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-methods-private, class, class-fields-public]
+flags: [generated]
+info: |
+ Updated Productions
+
+ CallExpression[Yield, Await]:
+ CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await]
+ SuperCall[?Yield, ?Await]
+ CallExpression[?Yield, ?Await]Arguments[?Yield, ?Await]
+ CallExpression[?Yield, ?Await][Expression[+In, ?Yield, ?Await]]
+ CallExpression[?Yield, ?Await].IdentifierName
+ CallExpression[?Yield, ?Await]TemplateLiteral[?Yield, ?Await]
+ CallExpression[?Yield, ?Await].PrivateName
+
+---*/
+
+
+class C {
+ ;;;;
+ ;;;;;;#m() { return 'test262'; };;;;;;;
+ ;;;;
+ method() {
+ return this.#m();
+ }
+}
+
+var c = new C();
+
+assert.sameValue(c.method(), 'test262');
--
GitLab