diff --git a/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index fc911d03205553a626719a0dc0c3f500571a0d65..b4820018aed10618b4babce2f3513235209b1ead 100644
--- a/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  *m() { return 42; } static async #$(value) {
+  *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 3963332d193f467d405b161903014fd77b863912..69981853c976ffb17d6217051ec5612243e81e88 100644
--- a/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index b476ac548a1efd0ca7f8e53aa00a933a837f9058..ff21ef06f3f06c480d9ad4674f87e5b32b0e1d26 100644
--- a/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js
index 04f3dda18fe50c4de2e874002d551463e3434396..8206125d7d956ca069069a680729de36470dea27 100644
--- a/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-gen-static-private-methods-with-fields.js b/test/language/expressions/class/fields-after-same-line-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..e71673d907b443cf5d3f18bd4245b841776a9552
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-gen-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-gen.template
+/*---
+description: static private methods with fields (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-after-same-line-gen-static-private-methods.js b/test/language/expressions/class/fields-after-same-line-gen-static-private-methods.js
index a7b69d61cc9c3d3a95b5440604956bb9df714cc8..9639fd2f9904298a5232a174357740407b57f323 100644
--- a/test/language/expressions/class/fields-after-same-line-gen-static-private-methods.js
+++ b/test/language/expressions/class/fields-after-same-line-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  *m() { return 42; } static #xVal; static #yVal;
+  *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 252484c0adfec1997b39785085805d261cebb08f..9f06a4102a546e722cd13dcbfa22cbf78135daac 100644
--- a/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  m() { return 42; } static async #$(value) {
+  m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
index e21b8a4dd595ad65140fa17dab93ed8d5cc71282..f5d7e71e4508310fde3ecf0965e89a2cce85be8e 100644
--- a/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index fa9c6081c54bac1dd965e29008584c8cd2da3741..e9e52f25ac37b5b94e014f5e4301a47f9a757eb9 100644
--- a/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js
index fd80b633561dd48ba33367f428ea88d578aeee99..dc0d84ce9705f809579b2e9c1ca7f8de45aea482 100644
--- a/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-after-same-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..17159d7df591762ac4c880440c62b945ee9b85f2
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-method.template
+/*---
+description: static private methods with fields (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-after-same-line-method-static-private-methods.js b/test/language/expressions/class/fields-after-same-line-method-static-private-methods.js
index a45087347c61a4ee7e252b0f97fa453c7094a33a..cd5594950dd1dcd8296997be997fd5d019456c76 100644
--- a/test/language/expressions/class/fields-after-same-line-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-after-same-line-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  m() { return 42; } static #xVal; static #yVal;
+  m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-names.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-names.js
index 4f92e5bc9f4f4212c78d4cd88a0064eb16df045d..bfb1108860112a6bfaafa53aa6c1461af231654e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-names.js
@@ -39,41 +39,51 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-symbol-names.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-symbol-names.js
index 80d36a6128f20c80d0f19802721aaf8333b09508..901648f55d644b35cc27bc914fb3c7620e7afb7e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-computed-symbol-names.js
@@ -40,35 +40,45 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index ec7fbec04ce6a867eb2ba425b77e5f37255cf555..a9e56846d0c79dc7490a3ea2ea503bcfe196a18c 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,12 +98,22 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-literal-names.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-literal-names.js
index b298c5f63316843c47fb49b8cc0f2e49d587628a..76a72a7f91e4abbae38beced01dda90275af2a70 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-literal-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-literal-names.js
@@ -40,38 +40,48 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-private-names.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-names.js
index 8a73040702ac347da45fee5be86ebcd6d74b2022..ed92d09c0f82ed995ee1ecb2acbc1a5a2c0781b8 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-private-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-private-names.js
@@ -47,24 +47,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-C.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js
index 87bb10775fe875722ab9550f1538144f66956043..fa307baf5c5078a26feb887cba15ffdc1351177b 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js
@@ -74,14 +74,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier.js
index cdf3f000f7c49a76a29e84fb2c9966adf40a76c6..dc4bf4b22674109d0c07ffa12413588624007a54 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-field-identifier.js
@@ -74,21 +74,31 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js
index bf0b03b253a135f4170addb25be3f5c8619666ee..5036153f12e31784abd6b26286aca98fc8184673 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js
@@ -95,15 +95,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
index 718948e0781eded7f6f013ee14d10505f79de3dd..d3d5c4c4891ab4606897a5930317cf3ff221d1cc 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -89,15 +89,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
index 9a45f465ed81bd28513c751b62c42317667ea20e..102070c8eef4102e105340010b48d32d1be73501 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
@@ -89,15 +89,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js
index f1693b695e64500e2b337c0d5b7f2337600bfe74..c0d8ba7d1ee66a666055a8dcc2d2772da9c7abe3 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js
@@ -95,15 +95,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 84e248f8a4c4036a072c783e10425298df27b121..7cf2aac6220ca67d22305f3d82c5e2737cd440c1 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  static async *m() { return 42; } static async #$(value) {
+  static async *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
index fa4f68e1b7a5702539c70b3b8e54091ba0362cac..1fea76cae8d8205a73ad9eb93fa9a81dc68d56a6 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,26 +111,36 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
index cd4791232b3435c14329fc3356719e7762f2918b..da8fe5611f451bd3c017d811965570bd3a2df01a 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
index d4209a9fd3d47d04a586fd15362f4954acaba307..2a00f8ca72ec540b49d6152bd6f47a27e334938a 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
@@ -111,26 +111,36 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index 98728988043da90fd8d535b11211b2d0cc3db1aa..31b3575d57f11de1424c327a730a4e032b4bd662 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
index cca95d074c254aa1cea2b81a5c0dc0ffe5e12e75..fdc6e94eca96a10e0e404d380d3cada518bb6d15 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,15 +111,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
index 8c1b3ec4ae170f71301afdf4bd3a4a8d0ba5241f..9a35ca9679c0a5552fc25c6b170f2796a925a53c 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -108,15 +108,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
index 3367d390f4229aefc5b8e13c464ba58b2cc1a514..a2591243a5257811ce284e47766e6644995b78f2 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
@@ -108,15 +108,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index 41b6ead3f01edbd2a0c5c072442fb61da0b39115..9b71691e319d0c333c2ac779c9e29566a644d542 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
index fae74f1829f2ebf3c89d419130e3af5da7687fdf..73a514b15d83253caeb2d15307cee7b5debad527 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
index a646301450100bba967884d00f8f05be91828a56..d8f41b3aa6f08d6959a748b892d5d39e56daf863 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 09fce367344ba3bba87a9e7b4e130b9c3e6a2029..807418f83cf34c3e38c015b8881aebaabda91286 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,15 +90,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
index c35ef2e3ca44ff127d8b85b541295e1ab6a16acf..62af4c16353a41a1749ff059af351a0f3df699fa 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -90,15 +90,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
index b3bae16d2727153200816bcbf323881ceee4ff3e..c6f01fda88533159fceee29a89848e7ced1c588f 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
@@ -90,15 +90,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js
index c898059164efec267d3e412bb2cec73b262da86e..38d8ff20947c19395f1a0e7950ebbfeb464ce50c 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-fields.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-fields.js
index 8f27dd87362ab4ccc154b77a29122480f29f3e0d..96ff7d881c8d70435dc05f779ec97da98b56993e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-fields.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-fields.js
@@ -47,24 +47,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-C.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods-with-fields.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e6610b25e16e5a403ec5b8343b8f115f2d9f62b
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods-with-fields.js
@@ -0,0 +1,98 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-static-async-gen.template
+/*---
+description: static private methods with fields (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static async *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods.js
index d8e030b0d5ae2e67f8167909bc7d440f8278ba3f..20f8d7aa0ee8760b673771043723f96706ce3423 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  static async *m() { return 42; } static #xVal; static #yVal;
+  static async *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,24 +51,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+C.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-C.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-gen-string-literal-names.js b/test/language/expressions/class/fields-after-same-line-static-async-gen-string-literal-names.js
index 95e1a4643222a1d493c0be754cad08200c4dae75..ce1018ae6f1abc231d32564d1664bc53861ce56e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-gen-string-literal-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-gen-string-literal-names.js
@@ -38,47 +38,57 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-computed-names.js b/test/language/expressions/class/fields-after-same-line-static-async-method-computed-names.js
index b32ed9b83f67e69d540d546f82111f58cee6c968..e0938c454433d83df371b9fd75db4983eaff7e6f 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-computed-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-computed-names.js
@@ -39,40 +39,50 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-computed-symbol-names.js b/test/language/expressions/class/fields-after-same-line-static-async-method-computed-symbol-names.js
index 392fb7b0a6d0e37e5dff91ce2c97410b868019a6..04091e6e964ab71d20e38a81d873e084f66b2996 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-computed-symbol-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-computed-symbol-names.js
@@ -40,34 +40,44 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index 5e932402aef61b5b3187454a0821a2b846bb4b00..e5426eef1206ee6f91c78bd6e21c56273dc7a8c6 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,11 +98,21 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-literal-names.js b/test/language/expressions/class/fields-after-same-line-static-async-method-literal-names.js
index 14f723d1dd5156f05069c1f966b70b3aa49704fc..166d40d02f8fb47effa9f7f05510b112abaa27b8 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-literal-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-literal-names.js
@@ -40,37 +40,47 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-private-names.js b/test/language/expressions/class/fields-after-same-line-static-async-method-private-names.js
index 2dfe19655fb8d8d5dde5466a50ab5e6945cebffa..4a042809375cf70273621b19c9f487d7fdc0af49 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-private-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-private-names.js
@@ -47,23 +47,33 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js
index cc3a4aef07acfae70a2f65b36190bc3755ce151c..6a1590440a8c65a2e00f9716e9f3b9af834ceab8 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js
@@ -74,13 +74,23 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier.js
index 6a6270a4785434c6938d9f3e7f4253b57080b59b..ee7569bd9350b2f27011111de182a62d2e2a880e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-field-identifier.js
@@ -74,20 +74,30 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js
index df53d38f9963fc2cbcfad477e01b69c0fd17b6ae..6b4d954e8691d4b054ecfc6856f5eb1279cbd466 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js
@@ -95,14 +95,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
index 950a23d17ac63bf2b462306e8f90e69b841b80b3..7a48df1b607e46ccda629910ad136bb3df8c20bd 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
@@ -89,14 +89,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js
index 2a734e15f6887bff66d344062eef267a9fed6018..c90bd5319b9a169c5b61b535356e41abb050e383 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js
@@ -89,14 +89,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js
index 2aeb93b8c839ea3671ed87d355aa2b5639e56893..7fb854b73c9786260b9fdb5e3e07bcbcd1de6f33 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js
@@ -95,14 +95,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index a1ebbc4c7a64c8dc7802ccd9831ab1811c8fc786..6df986a9ca1bd86e438ca6e7746b827d5a64a879 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  static async m() { return 42; } static async #$(value) {
+  static async m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,24 +111,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
index f0628386780c8d092c628be39642e21a481e51e6..3a88a620fb9fe151f6aa2650fdf57af66614725e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
index 3d80577fa5d43bd0aaa6ef941558ec62f46b02d6..8d834ca55044ab51d9d396cce54696cd9a632519 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -111,24 +111,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
index 842b65e3b8d45ccd8720befb50fe2a98369a6810..db2e674beb00dafe5ffeedfbfbb363c57eff39c5 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
index 02ed3506618ceec8f58b4a127168d657405304f6..d11fcb72c7eb1981c82caf30f7d68d5f75ef2b62 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,13 +111,23 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
index 194dc3d999febc75ff512d6117d060f356044a61..d54a82407f84780f17ddf550afad82d77aed5a30 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
index 018063c0e93754df808a37e81b96655b58fe3eeb..fd52de3d25d6490a112599eaf63deebda0d1252b 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
@@ -108,14 +108,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js
index a0124ed6dc5a711bc4f4cecd4caf4a2087a0929d..2bbc3368eef808da30bb24a0ff15966c78ce3b1e 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js
@@ -108,14 +108,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
index d121c084598e6c4db535f580f1cabcb09433d5ed..855072f5edf682b7caf24a0fe0c84d077bdbea37 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
index bb4679d89ffbfd7ff262b4809bb2545c71078eba..bc80961b633042468c5b9d10d79c7c153a747906 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
index 1460024a08ba900fe8561ceb93f842d94feca4a6..dcb3d360d5f80f623943fb2dfd76b7966b1356e9 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index f1ce0e6a3b649c2157b9e209019e786d09a082d9..01b88952fffbc8c2337f18a1b93ba6c2bcce3920 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,14 +90,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
index 741cc639d6a7a3f8b7b6fe215599ddd118894827..6d7d7a39c891a5de4a3a5ae372eae76ad62d47c0 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -90,14 +90,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
index ee6fedcc0d44852e9aa36426b8319a24957c2a08..1a04620757b6b7b51a5ae413ed11367719ea0bba 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
@@ -90,14 +90,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js
index ee079a906d69ec6213c362f41d86db04d60c21b0..1fe714522876c181938b60ace41d62f77c3dc8b9 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-fields.js b/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-fields.js
index 21a43260e1365e1dccc7504634fc876f022492b4..f5ffc73db5853689aab89412c62d2bd5b3264fdb 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-fields.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-fields.js
@@ -47,23 +47,33 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..9b6bbb6ce026fb0e5b61676fe701b857d2f08bc2
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods-with-fields.js
@@ -0,0 +1,97 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-static-async-method.template
+/*---
+description: static private methods with fields (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static async m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods.js b/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods.js
index 3a61adf3ff8815eb30b3d8fa312b40a5c085130d..a6bec3eb493aba3c31ed3ae92b78599f653a03fb 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  static async m() { return 42; } static #xVal; static #yVal;
+  static async m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,23 +51,33 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-async-method-string-literal-names.js b/test/language/expressions/class/fields-after-same-line-static-async-method-string-literal-names.js
index 9d0422cbdc71880a906119f1779cfdd65ef664d4..d9f7af8b183bdd4a200996ed5579db5ad62b8135 100644
--- a/test/language/expressions/class/fields-after-same-line-static-async-method-string-literal-names.js
+++ b/test/language/expressions/class/fields-after-same-line-static-async-method-string-literal-names.js
@@ -38,46 +38,56 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 7ed3135c5e212610db6e6087a7a314ba2aba7a43..ce4adc3b883ad268e24d9be6fb1c88429338d7f5 100644
--- a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  static *m() { return 42; } static async #$(value) {
+  static *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
index 6f0571f81cfa41dc526851e7051494efde774cb2..06356c852730c75d0baa79e351aed16f3f153ba1 100644
--- a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
index 67e21fb3f73d75d4d88c6f0d4d5ccf495f3c4cae..fa18e79e92e6d47e42423096b8abe7ff3e17fe92 100644
--- a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
index fd57c93431727f69a6c4be5e1ba79a2b01d8d570..f7307965b2d4be88a9bdec3a3344b5d35e6b932f 100644
--- a/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods-with-fields.js b/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..387d134558b4408ff50c55cdcae9e9e24ed4ff9f
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-static-gen.template
+/*---
+description: static private methods with fields (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods.js b/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods.js
index b7e9ca1ae2928894b7fea0183ae78c7f6e64a3d9..b23414123b9ac6bab8d15a28a861f1d25de842f9 100644
--- a/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods.js
+++ b/test/language/expressions/class/fields-after-same-line-static-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  static *m() { return 42; } static #xVal; static #yVal;
+  static *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 8b81ed9948f22b34f809db63ede9c510abbe2a32..72fd281cbf1a2c6e2d070e6bfe2061028b5b7fdb 100644
--- a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  static m() { return 42; } static async #$(value) {
+  static m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
index dba6451cf2ae7a62bf5dffb86c445d83058e4195..08ac599fc1c266dec509e58ec181b232207d1558 100644
--- a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
index 8ea5bb1746fd353c481c000ab6644ec7792e5ce7..c6d12d3884e7a2818d51a59528bc0c22a9973bd8 100644
--- a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
index f1ce1992d45893ecdd2806c059e3f3bc0d075755..4233c9282ddc541978a400dbd2f76169a725282c 100644
--- a/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..39c4a87e387d0bef980edad6aa2182acc2670063
--- /dev/null
+++ b/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-static-method.template
+/*---
+description: static private methods with fields (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods.js b/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods.js
index 8cb2832729fd6b085b7389e816634c2ebbbc4ec2..d79182d748f179b1dfc4cf8a44a8b38b2e1804f2 100644
--- a/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-after-same-line-static-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  static m() { return 42; } static #xVal; static #yVal;
+  static m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 5ccf01a63f5c44ee0ebde12ff15a6432a0460e65..2d1c0a1057e9f27eaa640749202ce069980c7f9e 100644
--- a/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -63,43 +63,43 @@ info: |
 var C = class {
   foo = "foobar";
   m() { return 42 }
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
index 4e45cd1f00f6430e78af3c9ee972238d66502455..60c154bcfc67fa5bb981bef419eb65dca6eab0e6 100644
--- a/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -64,42 +64,42 @@ var C = class {
   foo = "foobar";
   m() { return 42 }
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
index b72e78cfb09967ac7b56a761c2d26b212b96ebb1..ca6a339d7cc922536c88098c437eae5701307836 100644
--- a/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -64,42 +64,42 @@ var C = class {
   foo = "foobar";
   m() { return 42 }
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js
index 4aa37a2528b943dd3b7e21608eb614879e61e122..020842fa4cd2556aac288ab71348951ba42d7b03 100644
--- a/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js
@@ -64,42 +64,42 @@ var C = class {
   foo = "foobar";
   m() { return 42 }
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-definitions-static-private-methods-with-fields.js b/test/language/expressions/class/fields-multiple-definitions-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..effd6138657f679a4c399d916ae0e673c5acdc89
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-definitions-static-private-methods-with-fields.js
@@ -0,0 +1,119 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-multiple-definitions.template
+/*---
+description: static private methods with fields (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  foo = "foobar";
+  m() { return 42 }
+  static #xVal; static #yVal
+  m2() { return 39 }
+  bar = "barbaz";
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-multiple-definitions-static-private-methods.js b/test/language/expressions/class/fields-multiple-definitions-static-private-methods.js
index dec012b261bf51fd57b557b2849c95ade369ccee..073971189bb006adc3ce35921ed199aef6c7a3a2 100644
--- a/test/language/expressions/class/fields-multiple-definitions-static-private-methods.js
+++ b/test/language/expressions/class/fields-multiple-definitions-static-private-methods.js
@@ -27,19 +27,17 @@ info: |
 var C = class {
   foo = "foobar";
   m() { return 42 }
-  static #xVal; static #yVal
+  
   m2() { return 39 }
   bar = "barbaz";
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -91,18 +89,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 779ab2384bc4ba7be49836bd4a10b19b59c0930c..5eb792a6bf631b2cf63870bcdbad3c646f235c58 100644
--- a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,43 +61,43 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
index 8960c89dfb0638fcc94ae8091be5be5b2e8a2a82..ff89ffcfd88f6759c347c0dee85e51efea3a8ff7 100644
--- a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -62,42 +62,42 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
index 4840c98d9733aa802e816939d7773fc14398ebde..7f8e83b6c0b3d865a800c2db130048336b65b61f 100644
--- a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,42 +62,42 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
index d1ef00fc021d3daab0e60cc1f24d30d05935285c..9400b141e6a47c369b3714dd4c413ba11c677825 100644
--- a/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
@@ -62,42 +62,42 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods-with-fields.js b/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..ff6b10b56777c2dda5968d48b5854ff768d35db0
--- /dev/null
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods-with-fields.js
@@ -0,0 +1,97 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-multiple-stacked-definitions.template
+/*---
+description: static private methods with fields (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal
+  foo = "foobar"
+  bar = "barbaz";
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods.js b/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods.js
index 85791c2060eb4e44c5fe0f57115fe8f63b008dac..72f98a23838108fd40a6647755c3982409cd9502 100644
--- a/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods.js
+++ b/test/language/expressions/class/fields-multiple-stacked-definitions-static-private-methods.js
@@ -25,19 +25,17 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal
+  
   foo = "foobar"
   bar = "barbaz";
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -69,18 +67,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 042ffc25676b32d82087bb5b9710bf3816fd2c11..51991185274f7ad15902ab884832a5d637336b18 100644
--- a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
   m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 76a4c887ec8ff4d27005989677f7e4505a0502ee..ddbdd56fe2609f38fc89a551889b63e6d72cae4d 100644
--- a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
   m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 33950f9664bca373f3cbf411d449a1a98cec5867..3fb1465028b1b49d9232677a4e90dba4baeb122e 100644
--- a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
index ada54f015859193fcfa6dbcef57451a80ea372e8..6f689fd462d940207fa66c3b1e8620fdbfaad4af 100644
--- a/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..00856fe6259d4b0778fc585a69384924720041fd
--- /dev/null
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-new-no-sc-line-method.template
+/*---
+description: static private methods with fields (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal
+  m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods.js b/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods.js
index 5c41cadc9a6ff15f64074d23f63a6647ad02766e..7c570063630716c93a74613434c292f28d99ed01 100644
--- a/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-new-no-sc-line-method-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal
+  
   m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -56,18 +54,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index c4b9e371376ad3193154aaafd56ed990822e26b2..2feaf8acde44f253411efe91069e7711aacd9019 100644
--- a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
   *m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 941da6fcbfd38c663883d81d1070d0dc5d5b20f0..fee12a971c6f32fecbbf15609f9853aaeb301b5e 100644
--- a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
   *m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index d7a6c8ef22dd079f5d82c48f38a14853707ee232..5de6b1771be656b7738fee58d8aa1d097f71734b 100644
--- a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
   *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
index 154156c8e6798b7ceb6bc0a9abd72843dcf28678..4829ffee5368b537f0bfe5171a16fd311a25ad43 100644
--- a/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
   *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods-with-fields.js b/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..d6ec72256ee07085561720056231c0d79bea8c39
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods-with-fields.js
@@ -0,0 +1,85 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-new-sc-line-generator.template
+/*---
+description: static private methods with fields (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal;
+  *m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods.js b/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods.js
index 525cb72141a0900ae2093116f97195121ddaa478..42dfb674ce15f1105da5cabd7298f27a09b98f5a 100644
--- a/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods.js
+++ b/test/language/expressions/class/fields-new-sc-line-gen-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal;
+  ;
   *m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -56,18 +54,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 89265d3fc27c5c2604e8d986ac9f932be78e1f08..3da00f169a36902e69260ccf92de31b9c34f07b4 100644
--- a/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
   m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 616f3a3f7aca0d760faac47e2c23fdd413f05402..4566198a9d1ef649fba863c390eed6cbf321aaae 100644
--- a/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
   m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index d3ec9ff36e56e5901c07ae0a11c521850a13650f..dd76e7f09219474ebcc406318f07e7b4aff69f98 100644
--- a/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js
index ad929a09c748fc2e96e33fd0b4d46d39ea1349a8..21dd9fda45cdfd6ad9f01d6a6721058be68eafe9 100644
--- a/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-new-sc-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-new-sc-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e2c4a29765b03f283607cf30aa86e0951e41a6e
--- /dev/null
+++ b/test/language/expressions/class/fields-new-sc-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-new-sc-line-method.template
+/*---
+description: static private methods with fields (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal;
+  m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-new-sc-line-method-static-private-methods.js b/test/language/expressions/class/fields-new-sc-line-method-static-private-methods.js
index 4074913bf368f266d0c306c6c5a9160f15954daa..6352a38fbff9e16bbb555fd95dc20b27e762aaa0 100644
--- a/test/language/expressions/class/fields-new-sc-line-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-new-sc-line-method-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal;
+  ;
   m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -56,18 +54,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index d656a760974197ed0df88adba1f3363610a0be9a..eb3667958eb0662a7920bdfa1b8706fb91859681 100644
--- a/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -60,41 +60,41 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js
index 6ee58c844cd21a6ab963bb271ebb2366623a8335..6ed93f3153c19e5977ddfe6b9d5388fd0d545f3a 100644
--- a/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -61,40 +61,40 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
index 6dc6cf0c17a6ca338c2ba4f977bff2aa1cb3fe4b..cd41048da976c000be198f3b3d6901871ce47c09 100644
--- a/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -61,40 +61,40 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js
index d5a380ed39a9717bc6f96ca039739fb7f086cbea..0c8c0ef0538539c15f4ad23988e3fa0b7c43bf1f 100644
--- a/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js
@@ -61,40 +61,40 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-regular-definitions-static-private-methods-with-fields.js b/test/language/expressions/class/fields-regular-definitions-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..5014d5a16cf4ec073204cc82990973d21337d760
--- /dev/null
+++ b/test/language/expressions/class/fields-regular-definitions-static-private-methods-with-fields.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-regular-definitions.template
+/*---
+description: static private methods with fields (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+var c = new C();
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-regular-definitions-static-private-methods.js b/test/language/expressions/class/fields-regular-definitions-static-private-methods.js
index e1ef400f13bf2b0804af575845cfec3d64c3e267..6e8a5312b985ed4169d0fb308152350731177a4e 100644
--- a/test/language/expressions/class/fields-regular-definitions-static-private-methods.js
+++ b/test/language/expressions/class/fields-regular-definitions-static-private-methods.js
@@ -24,17 +24,15 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal
+  
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -44,18 +42,18 @@ var C = class {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-same-line-async-gen-computed-names.js b/test/language/expressions/class/fields-same-line-async-gen-computed-names.js
index 7f8d920fec9e9182c4d791eaecacba9b9e25e135..348fbf97989708b53c1acb8989473039671cfe33 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-computed-names.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-computed-names.js
@@ -39,41 +39,51 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-computed-symbol-names.js b/test/language/expressions/class/fields-same-line-async-gen-computed-symbol-names.js
index a8d955ec20bad0697d17bd1fd44c9570aeff2065..dcbd8b973f74fa79b671753c39e68e73e3bc2d0c 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-computed-symbol-names.js
@@ -40,35 +40,45 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index b748989fa0885637fbc4804e04bdc5b5d8f991bc..0545679928ffb3ad625a0d9f25be0db970ef5308 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,12 +98,22 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-literal-names.js b/test/language/expressions/class/fields-same-line-async-gen-literal-names.js
index 861efccce1361a280d3ac68685ed542d82920656..8e727897acbadec4bc128849f827fc727e4be07a 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-literal-names.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-literal-names.js
@@ -40,38 +40,48 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-private-names.js b/test/language/expressions/class/fields-same-line-async-gen-private-names.js
index 05ddab3fe4c70c4d35253c2a754967b23023ffb9..dc2c8f8f7c9322bd5d11060d5c38d435feb63713 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-private-names.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-private-names.js
@@ -47,24 +47,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-c.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier-initializer.js
index 19577f96c5639fa8cfa46596b50830740e1290d0..481ae0f9e4c2d40449d89bdb09f057f26352b481 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier-initializer.js
@@ -74,14 +74,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier.js
index 998d5833e247c4b549c69ef5e7a14db34d180a50..0d541830d82a54ed05abb6cfb23a856d4748ee30 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-field-identifier.js
@@ -74,21 +74,31 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js
index 7c5a1ade6266fa62764954143fbb9ee2e6f99c1d..51a25b6add10eb776678df4964417f87b2a86ee1 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js
@@ -95,15 +95,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js
index 0414c253924baac8357218ea2846035e5f1125cb..846a3ebf41f414e2a0be614436ccb539ad73c59c 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -89,15 +89,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js
index 26e2bbeb288a5a320bc7b41f35807119c6cb4e4f..742906c892629bdc7404a54c389230ac08bbc8aa 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js
@@ -89,15 +89,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier.js
index db34f0e0277806f06da4e123b2f0d5023f36bd26..16deb05d5ca762b4683977fc90f9ec545d07eb91 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-privatename-identifier.js
@@ -95,15 +95,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 60267b241e6d99050e2093c60c298166bc44955d..5858b16d6515201b72391fb34932180bb0e5bc2e 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  async *m() { return 42; } static async #$(value) {
+  async *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
index f43c71c90b0d48b67fccf46d8f3de3bedf1dc1ad..b15158abc9876aeefdad83780c3610824979a567 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   async *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,26 +111,36 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
index c49fe30888441586eec512d3cd2a8e046e51c6b9..360aedabc3ae3d43a0289a1a3045039de28ebe3c 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js
index 5a04dc9dd4ed469bf54c63546a8ff26c9e5ad20b..df4afec8167627d80acc4d91874d5130abd880c3 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js
@@ -111,26 +111,36 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index a2735fc80159852f473c9794912631e11add7cda..0d367c08f110ad3f2f843c967d86a3aff9dab073 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js
index 3d4332e3cbf942c80a987bb20dac146413beb9e1..00758cd361ca078feea1cc77c67c9509957c5428 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,15 +111,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js
index f9966925656e53356b644dbefb5f3e2072344a08..4fe3d61879bf4255d29eb4e451505b3b6ff50738 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -108,15 +108,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js
index f412f24f643b8d16a6fc827e6de5e98525ade737..744a6314b4386390f7f85d424e8b0f9d73ffa563 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js
@@ -108,15 +108,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index 4a67be1fdd7a3b50b96d81934cc74c323c5bd6ad..62b242c0b2ad64217936c4fc789631573f003bce 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js
index 5bbb93a64fe7bd757385b357741ea2c0fbfcd5b7..26509ce6ce6a4f2305f3611fcf8fde1904f2da47 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js
index 1ee0e6c603019596e78082c5f221dbd5e79406f5..5b10ecd98dfd71a3bec2c30ade371d05c58a69d5 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 0fcad31030dbf9ca46bc3701b22f2170ede6837d..9ac4140759b54e98879ef00d5242bb64f49afe73 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,15 +90,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
index 7c61c13b20cff5da79686f94a8e99431678aab93..063799717f4bec66c8e7212be389a07bd6fb60ad 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -90,15 +90,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js
index 8fec6d625255b0b526bf88cbdba3eb2f1eda34bd..4e73cf61306031e4cd0ff12698769dbf92ed6827 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js
@@ -90,15 +90,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier.js
index ef41a0853ac750339159395ab5a5edc3b81277b6..faf913c0aa9532798d7d3ca476e754a5855e6130 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-rs-static-privatename-identifier.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-static-private-fields.js b/test/language/expressions/class/fields-same-line-async-gen-static-private-fields.js
index 40d189e4db24f54ea4199081f1a0532d3b168870..8d3c3eecfb903f3896c916d26d5f8c83a9b1cc6e 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-static-private-fields.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-static-private-fields.js
@@ -47,24 +47,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-c.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-static-private-methods-with-fields.js b/test/language/expressions/class/fields-same-line-async-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..b54546d1352a12d032b3c66859d5a5c52fe8f64f
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-gen-static-private-methods-with-fields.js
@@ -0,0 +1,98 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-async-gen.template
+/*---
+description: static private methods with fields (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  async *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-static-private-methods.js b/test/language/expressions/class/fields-same-line-async-gen-static-private-methods.js
index 2bbac54e1b6b66fcfd5daae92b66e711268d0736..f70b80a50509a7991034914692a66fe037cb22f6 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-static-private-methods.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  async *m() { return 42; } static #xVal; static #yVal;
+  async *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,24 +51,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+c.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-c.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-gen-string-literal-names.js b/test/language/expressions/class/fields-same-line-async-gen-string-literal-names.js
index 108d2cf8f11c9b1c3dc181b7bc9ab3fee0a63b58..a843f8cabb76b32574096302e7242a969887d289 100644
--- a/test/language/expressions/class/fields-same-line-async-gen-string-literal-names.js
+++ b/test/language/expressions/class/fields-same-line-async-gen-string-literal-names.js
@@ -38,47 +38,57 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-computed-names.js b/test/language/expressions/class/fields-same-line-async-method-computed-names.js
index c358d94b9be914ba198954ac57ded47186767426..a57afbd3073010d103fe2203f1f2311ab654b3ad 100644
--- a/test/language/expressions/class/fields-same-line-async-method-computed-names.js
+++ b/test/language/expressions/class/fields-same-line-async-method-computed-names.js
@@ -39,40 +39,50 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-computed-symbol-names.js b/test/language/expressions/class/fields-same-line-async-method-computed-symbol-names.js
index b211484c3bf199e0c3ea9478c9bc7cd5d8e8511e..55c28114a7b1b216bc9dbd10ac4361e4edc32313 100644
--- a/test/language/expressions/class/fields-same-line-async-method-computed-symbol-names.js
+++ b/test/language/expressions/class/fields-same-line-async-method-computed-symbol-names.js
@@ -40,34 +40,44 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index dc9750b233c9ce0b02a273103e127a6644f98d0c..8edf845943898a6b399cd5275110e269b9635bed 100644
--- a/test/language/expressions/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,11 +98,21 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-literal-names.js b/test/language/expressions/class/fields-same-line-async-method-literal-names.js
index b4dbeb9bc4e987563c68966dd55b89bc16dc558d..4923ef63f41062898230a8c48099780248c8a320 100644
--- a/test/language/expressions/class/fields-same-line-async-method-literal-names.js
+++ b/test/language/expressions/class/fields-same-line-async-method-literal-names.js
@@ -40,37 +40,47 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-private-names.js b/test/language/expressions/class/fields-same-line-async-method-private-names.js
index dab4667908d8d25766dc0c42dcd69791fbd68f2d..aa67b1faf9811d3388c7619f5b47d649dfe91a0d 100644
--- a/test/language/expressions/class/fields-same-line-async-method-private-names.js
+++ b/test/language/expressions/class/fields-same-line-async-method-private-names.js
@@ -47,23 +47,33 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier-initializer.js b/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier-initializer.js
index 7492d169e44db9b30b96e980839cf6e140b5533f..56dd742b10b21148cadfc61eed9ee1c870e59226 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier-initializer.js
@@ -74,13 +74,23 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier.js
index 418b6bb5cb22c8c9afd8531bab01569d46c00ee0..d338ef06b751e360f34e963c0bab4847ce21deae 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-field-identifier.js
@@ -74,20 +74,30 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-alt.js
index 5f99dd5ece8b6c7e372f9061df96a6b3da713cb8..a93dd1dace226a001e6e463868b55755a767cb47 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-alt.js
@@ -95,14 +95,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js
index 2ad6e564e1c872a3c77622989cc4dd17ba8e345d..c611f6abb827bcadb237d042c694a4078b8d0241 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js
@@ -89,14 +89,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js
index 43367d150e8fbe6c8a0893d3882151807f86a003..7bd37f635b80ccb48551383b40e85bc80008fafd 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js
@@ -89,14 +89,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier.js
index 3ec6a7ceb206bb3cbc4298e98e758e23c81c61eb..8be0a72eff955a6edf5d8310e3b007053b24cbb1 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-privatename-identifier.js
@@ -95,14 +95,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 26bf78ab935d8bf89043a52f35acd0694124e774..f2d7070a42aedd8be138a931a588607174bad710 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  async m() { return 42; } static async #$(value) {
+  async m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,24 +111,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
index e5122fd210c10fea498f326b12f8b234fc488e1d..b7e573ad4897cf7229434ca822acd50dc06f5f23 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   async m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
index 7a831c45c68f815aa3311378668a4c432a5ac420..51560cd3cefe28b46b85c22ded496fc01ba53c3b 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -111,24 +111,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js
index 8a32100ecc8a5043aa9e85114b28ceb80afb37ab..7612ed4cb3056c2639aa8aba916be0ff8ff80984 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
index 54ebe240d2241e3be8f3092a024ee3a5593750e3..cf0352f99b2ae956a611a5f9f02637a92e1ef35c 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,13 +111,23 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js
index cf3e86f543c93f48c93642b964ea91568736cecd..485d37f1d6ccc52ff1db57bfb3afffce356f55de 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js
index fc0ec082b3aa50cdfb95485495e7d75a860b218b..36beb62fd0496951081ae620e0a20c49994198f4 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js
@@ -108,14 +108,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js
index bfeede6da5eec04d3caa027ac6fc2320f60258e8..ac2f83f229243e960105ad983f2daf9b48780e3b 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js
@@ -108,14 +108,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
index bc9f3384d32878f2c906455fd2c74289887e6544..4cfdf2fbd30cce2eabf53b237b4396f25a501335 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js
index 3fe7bf6f27784576bb2fecc0cf56126ba6f8d30e..66e5920a2ae92316e243cd94f7b04e8954f88823 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js
index db6376c81f13eada7038bfd1a659a91379b55d4b..e1801401fc5c410167a4f8e396cedb8ef9a54d1d 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 2a6168162d53c5e47805f9a413c453eab10f7c8b..206001ef52aba47bf2a0713a670eda813e66550b 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,14 +90,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
index c5c15676b3cd2d3ac10db866fd3f555f097e6ca8..5149c0353c2cd5d7424b98c032bc7291ef4e8478 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -90,14 +90,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js
index b37205542016fb8623b5097a2b11c738ef4beb4f..193d57da2652036b01c36dfb9931478a30f73a39 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js
@@ -90,14 +90,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier.js b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier.js
index ca856185247e51b20c717331b3f7849f68b033ab..da93e94361d88fa88f96878f8447366927baa9f5 100644
--- a/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-async-method-rs-static-privatename-identifier.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-static-private-fields.js b/test/language/expressions/class/fields-same-line-async-method-static-private-fields.js
index 2370de7b5604eb56cd54e2e13516fe31e8b51c0d..d942db06c9c4765224f7965b9a2f9bbbbd617f30 100644
--- a/test/language/expressions/class/fields-same-line-async-method-static-private-fields.js
+++ b/test/language/expressions/class/fields-same-line-async-method-static-private-fields.js
@@ -47,23 +47,33 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-same-line-async-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..700484810f264c738a6ab84662f056125eb75973
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-async-method-static-private-methods-with-fields.js
@@ -0,0 +1,97 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-after-same-line-async-method.template
+/*---
+description: static private methods with fields (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  async m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-static-private-methods.js b/test/language/expressions/class/fields-same-line-async-method-static-private-methods.js
index fadd09677c5dfe5c49a602ed2d082919f0200dbf..af8f5b912cd32d1321f5409d5f77fcd03422e78d 100644
--- a/test/language/expressions/class/fields-same-line-async-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-same-line-async-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  async m() { return 42; } static #xVal; static #yVal;
+  async m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,23 +51,33 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-async-method-string-literal-names.js b/test/language/expressions/class/fields-same-line-async-method-string-literal-names.js
index a311fd7c94745f7588d2f75deadad839cb6c56f2..73f67f4a9a157805c9fb60f93f984cb970da5461 100644
--- a/test/language/expressions/class/fields-same-line-async-method-string-literal-names.js
+++ b/test/language/expressions/class/fields-same-line-async-method-string-literal-names.js
@@ -38,46 +38,56 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 66d0cc40fd23741af819b203e8f16ff41d39115d..c0f6451fafd49be8cf6f4919c174c0e78ef6a884 100644
--- a/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }; *m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index beb17a445421c04d92796e3c21c941555760b2f0..5c42a9ecee3637a04afac9c9acb97c62f3e9ef21 100644
--- a/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }; *m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index ca5a52108f2c760a2d4f6ccfc79541e0a558cefb..a6b44f41605c5eb3f6ff5173e0b0b3b86d8776b5 100644
--- a/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }; *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js
index ca34befd925090c9f152eb7e50e9cef65a15f468..34ea16384fa4fe083b93fe4df00ed85bcc7568e7 100644
--- a/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }; *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-gen-static-private-methods-with-fields.js b/test/language/expressions/class/fields-same-line-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..4c713a50238184dd76cf20548088882be7a7226c
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-gen-static-private-methods-with-fields.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-same-line-generator.template
+/*---
+description: static private methods with fields (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal; *m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-same-line-gen-static-private-methods.js b/test/language/expressions/class/fields-same-line-gen-static-private-methods.js
index d659b01a947f99924af022280f0cf17ab1c06ec3..4ef5906965314ea1a75aa89805ade757d0c87a45 100644
--- a/test/language/expressions/class/fields-same-line-gen-static-private-methods.js
+++ b/test/language/expressions/class/fields-same-line-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal; *m() { return 42; }
+  ; *m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 8bd431c404995803c5cd348f98b54ae7b05f258a..7a6d2a93081555d7c9dd9bd68ecf823d89a8081c 100644
--- a/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 var C = class {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }; m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js
index ef3c0c7ad404f446aff6c938ba3fb52eb295718d..bd54b4696128629b6cc37dfca0e73413579d01ff 100644
--- a/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }; m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 3cc1e099208ca42234de47e3bb33fabc5274b064..2dc77c4d4a9c4a8710a2efb2f9e15bde7105b8b5 100644
--- a/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }; m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js
index 5dfeb484e6ae158b17f40fb9ba56c1a9509a5899..1772d74c12368e0a30a79e9bc1aa50177bdf2b0f 100644
--- a/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 var C = class {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }; m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-same-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/fields-same-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..a694c74b4aba89ff99157ffef6f146afdd75eee0
--- /dev/null
+++ b/test/language/expressions/class/fields-same-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-same-line-method.template
+/*---
+description: static private methods with fields (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  static #xVal; static #yVal; m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-same-line-method-static-private-methods.js b/test/language/expressions/class/fields-same-line-method-static-private-methods.js
index a1c0c40cd5e452655aeecd35298bd15c662563f5..86046ecb28062c2750b72a491b07f6b5260658dc 100644
--- a/test/language/expressions/class/fields-same-line-method-static-private-methods.js
+++ b/test/language/expressions/class/fields-same-line-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 var C = class {
-  static #xVal; static #yVal; m() { return 42; }
+  ; m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
index 826c112aa840a1004bb9e291fa7a78b89a05a8e6..f91bf29fbff1013e581efa0365b455e6ccf83e8a 100644
--- a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 var C = class {
   ;;;;
-  ;;;;;;static async #$(value) {
+  ;;;;;;static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };;;;;;;
   ;;;;
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
index 57027d8e82cd1233279e0d9a5a13e17dc4b76f71..55fecc3a8d24abd0c877538927ab9966ea8d840d 100644
--- a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 var C = class {
   ;;;;
   ;;;;;;static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };;;;;;;
   ;;;;
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
index d4c4195bb9134ffefb8cd8b04c73d005fd3ec9fd..234b1969af9754bd5051b3a37d37226f38158c1d 100644
--- a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 var C = class {
   ;;;;
   ;;;;;;static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };;;;;;;
   ;;;;
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
index 4331108e29b71e88fb5a71f11e00f531c1d23432..71fb389cf876fe9e4332013d0dbed4c73bc754d9 100644
--- a/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 var C = class {
   ;;;;
   ;;;;;;static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };;;;;;;
   ;;;;
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods-with-fields.js b/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..8ff337d331d53defb8fa4a0e927a25e28b90377b
--- /dev/null
+++ b/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods-with-fields.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-expr-wrapped-in-sc.template
+/*---
+description: static private methods with fields (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+var C = class {
+  ;;;;
+  ;;;;;;static #xVal; static #yVal;;;;;;;
+  ;;;;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+var c = new C();
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods.js b/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods.js
index 32636c420dc8d7dbf178aededea602c7b76532e0..5dc4b0a3ac8157302a23b2c1d8876eb6915bcda0 100644
--- a/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods.js
+++ b/test/language/expressions/class/fields-wrapped-in-sc-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 var C = class {
   ;;;;
-  ;;;;;;static #xVal; static #yVal;;;;;;;
+  ;;;;;;;;;;;;;
   ;;;;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -46,18 +44,18 @@ var C = class {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 9371edf28058507ecc3a63fb4c1bef6ede5a0e33..14a21f7e65cc653f74144776f27d8d7cc64f62c1 100644
--- a/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  *m() { return 42; } static async #$(value) {
+  *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 530f0feddb30315db01692f3ca2251dc89200e3a..6d5be480704d1f871bd9dbf93b0192746580d69f 100644
--- a/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index 7f9fdda34169520a873ecae86e478ff3b761a802..580b11ce447a6ea5c216720f8a7c214eb03d6229 100644
--- a/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js
index 0cefd9ca0232adb7ac151b1e31860016015804e5..9e661599341fb9604fb2204ee911aa83d245b934 100644
--- a/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-gen-static-private-methods-with-fields.js b/test/language/statements/class/fields-after-same-line-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..f23a67eecf5515b588436fb20e489c6daf99f8eb
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-gen-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-gen.template
+/*---
+description: static private methods with fields (field definitions after a generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-after-same-line-gen-static-private-methods.js b/test/language/statements/class/fields-after-same-line-gen-static-private-methods.js
index 00ed8463beba63a4e03b2ab40f9a9cdab271b048..07a8b44bc0915e8be0a43439ff73f06c40b7577a 100644
--- a/test/language/statements/class/fields-after-same-line-gen-static-private-methods.js
+++ b/test/language/statements/class/fields-after-same-line-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  *m() { return 42; } static #xVal; static #yVal;
+  *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 314c7a6157563eac3d75792c89e82add04914af0..395e1098bf8530786b4d3af85036fddf331f3ceb 100644
--- a/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  m() { return 42; } static async #$(value) {
+  m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
index fcf17e7581f6dee79bc94edef5ada246d5894deb..4d2481015e6d73e652b63df52058ffe021f6291c 100644
--- a/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 1ff8aa7651ff5ee19d28e26fbf6f70c11c279076..4c0db20b25eb1ea90be0ebd95df9642bc93967f7 100644
--- a/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js
index f0fd6fe03d390bb461a498e63f895191fd657a70..cc30c68602344444f55d5b04c0340f0014e19691 100644
--- a/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-after-same-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..022da1efd23e0b5ba7f3b527db64086cccb91519
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-method.template
+/*---
+description: static private methods with fields (field definitions after a method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-after-same-line-method-static-private-methods.js b/test/language/statements/class/fields-after-same-line-method-static-private-methods.js
index afdbfc13c648ef18cccbb76934f5a1e56e330ed9..1d6cba4280e85f129297fc9a735ea1877e208407 100644
--- a/test/language/statements/class/fields-after-same-line-method-static-private-methods.js
+++ b/test/language/statements/class/fields-after-same-line-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  m() { return 42; } static #xVal; static #yVal;
+  m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-computed-names.js b/test/language/statements/class/fields-after-same-line-static-async-gen-computed-names.js
index f6d8311611b54df45ed835a9c61f9d36a732fd89..ee272af5c2e219c7967868509b5a1a0e0b4fcf21 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-computed-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-computed-names.js
@@ -39,41 +39,51 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-computed-symbol-names.js b/test/language/statements/class/fields-after-same-line-static-async-gen-computed-symbol-names.js
index 6d538d492d369ade3dbff9cfb6a5e259d9c2d246..dcbb623ebffa518c8decd0fbb13a9ef21f1af258 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-computed-symbol-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-computed-symbol-names.js
@@ -40,35 +40,45 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 4193fd5db72db5006b4514c73d0ec549609e25b2..bd780916cc60150b8e6fa738b22d4e934fe2cd38 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,12 +98,22 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-literal-names.js b/test/language/statements/class/fields-after-same-line-static-async-gen-literal-names.js
index d6dea1573b517c76f58b53b72278cfd05307f774..23533d37d03f5229f7d6e971b473dbeb6d658413 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-literal-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-literal-names.js
@@ -40,38 +40,48 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-private-names.js b/test/language/statements/class/fields-after-same-line-static-async-gen-private-names.js
index 3262f4498c49f3c52332b4c170721589a402b09e..732c84c1b4ccf9fd7edfe0cdb48da4b02201c047 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-private-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-private-names.js
@@ -47,24 +47,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-C.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js
index c0d859ba0dcdfc5443e10bc436ed1feef9d0e447..40616dda7731d2dc7f38884ea14b05dcb335ca3a 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier-initializer.js
@@ -74,14 +74,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier.js
index 84fe4503136c4f48760f7dec52416db5f2161ff5..eb6b0dd38756713a4f5701524c1282900055228e 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-field-identifier.js
@@ -74,21 +74,31 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js
index 545545a6796ec89e094e4792aed11c925c806458..b3bad0c17ded0e43ee441d3e53fc82cfd31ecca2 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-alt.js
@@ -95,15 +95,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
index 3e40782756cb01cf3da8ea14b9c705c0b83896a1..7b6b59504b6f62033570140a1bbebf5df78c23b3 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -89,15 +89,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
index 0bae129936315dc0b1ffb1e4c3d2513cd412e363..8f69917d795de33a3d7a1716a917a166a18fbb05 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
@@ -89,15 +89,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js
index ae07249fe7a3cf4867c81ad372ac33e5a8342a16..6b7dff8d51ca4b91940bbe6535230be0c5c9e118 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-privatename-identifier.js
@@ -95,15 +95,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 69a193568074e0042d800353204bf6f7d23741f4..929ab0f215e2a1406f3691b7099d8628310c61cd 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  static async *m() { return 42; } static async #$(value) {
+  static async *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
index 34953644e6e36ca3a4e6f1bad1a0c2b5685ff511..cac96c4d83ac9db2fa7d8580d216b4e46b8f3276 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,26 +111,36 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
index 894787f2c8347e9633a3de134e7a91d38306a3d8..c9b7092ed7e0ed9d1b2325ef7607185e2eadea2a 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
index b99a59d829b73e78778b27b7924e222f8510d8f0..f3be22f3ad8c2cac041195a5c62fbf4ffc8a1644 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
@@ -111,26 +111,36 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index efb94dcd9f59d028e4784257fe83e8d442e93286..c3c9c958c3908750e12db17a5041712ea9586269 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
index e7b11c308421132659946c270c81ce75a8226046..b8a0a51ea69938dec523bc06a5ec9f70e8cba457 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,15 +111,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
index 2f1ced343475e5a0b4ea8e1751d9419d49265035..4f9f46333f9ab80005455db868dfc5401dc96865 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -108,15 +108,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
index 9bd67953577f6dccb41a1ba4a3178d5df0725385..cd6c967e8dc23de5ea9ded67c9d23323938d2625 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
@@ -108,15 +108,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index e0c1b6eac9421d8c116d4776f7cf7e22ea5e0cc2..45f75f47df7c415f47c5dff783bb6bfcca8906c8 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
index 74f43bce35991ed39145c817af7d6e0512ec0b11..a1caab292622051a207603d0b3488d0a9a1c864e 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
index 27fc914429e0996fdbb8382b4bbede5832bea76d..c06b603e54609dc8e84012e52f817be03555a6ec 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index caeb85e57efed07f59cfdd3685d80570f84afdb8..2efd42533bcb12894510002e94809ec2b51daf9a 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,15 +90,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
index 5e596a3b25fc72d538a201ea1c024b4d9ef4033d..2be74590f1aeb9ac130ab3001274f7d61e29ebd9 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -90,15 +90,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
index b1ae4c245b6872bea8a9bf7279971fcd3be93eaa..58aea799e8fa5b55ccc48f3bf8d632eaeeeb4aae 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
@@ -90,15 +90,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js
index 1859796b85d6d9d818d5e7bbdd7c5ad8f29e445e..112aa8349a7ff3d29543d120dac0d0f8b1905bde 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-rs-static-privatename-identifier.js
@@ -96,15 +96,25 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-fields.js b/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-fields.js
index 2e337619da000c41c068e9ea0c5312ceee365fb4..9fb60f084c4274b0922c96f83f68237c561ea6fa 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-fields.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-fields.js
@@ -47,24 +47,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-C.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods-with-fields.js b/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..299d20e566d508fee6de4a56d97e66a6ae31e892
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods-with-fields.js
@@ -0,0 +1,98 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-static-async-gen.template
+/*---
+description: static private methods with fields (field definitions after a static async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static async *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods.js b/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods.js
index fb473a75a77af3f52e5dbad45946be18f389f3bf..b85c107081e772cb750fab3bce97e6b1ed2dc3ab 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  static async *m() { return 42; } static #xVal; static #yVal;
+  static async *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,24 +51,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+C.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-C.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-gen-string-literal-names.js b/test/language/statements/class/fields-after-same-line-static-async-gen-string-literal-names.js
index 6b8d8536d3e27f4be33f621c358112415a4fb2de..54f379f5892cb7098a6624d8af4853c06f64fe04 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-gen-string-literal-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-gen-string-literal-names.js
@@ -38,47 +38,57 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-computed-names.js b/test/language/statements/class/fields-after-same-line-static-async-method-computed-names.js
index e628b3ac5672cfec832e3e4fa2582c3c546979e4..ac3c2270cfa73bf78b7f35fb644a65655b665cd7 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-computed-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-computed-names.js
@@ -39,40 +39,50 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-computed-symbol-names.js b/test/language/statements/class/fields-after-same-line-static-async-method-computed-symbol-names.js
index ebb19a426fccb67299a9a8ef4a5c10764c6588f7..330995b9fc48c2185b7fbda76b1beb049314cc4d 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-computed-symbol-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-computed-symbol-names.js
@@ -40,34 +40,44 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index e4b1f887e2b4422d21895af457f221f01a9df5c2..dd4e7b07789c83d26831cffe5b972716482646e9 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,11 +98,21 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-literal-names.js b/test/language/statements/class/fields-after-same-line-static-async-method-literal-names.js
index 6593a6c52a0d56ca25f4efeec01ab48aaba52f1c..909e4787be6425294307d3b00e9890474062a45b 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-literal-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-literal-names.js
@@ -40,37 +40,47 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-private-names.js b/test/language/statements/class/fields-after-same-line-static-async-method-private-names.js
index f37ea74df696a727e554878f3fd7526256dd06bf..5562be772bde4729151be62f1f6b3038c0da0064 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-private-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-private-names.js
@@ -47,23 +47,33 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js
index ccc54913a7c4b2fb090e909cc55cf62414371c29..3c3a4e3a49ec7c2e0db3f94f03a8827d1b2757d8 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier-initializer.js
@@ -74,13 +74,23 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier.js
index 2fbf002c49e57bb9a4d0c797759841479715508f..f6af541db47193ef1b00e42c4796e9c8312870c9 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-field-identifier.js
@@ -74,20 +74,30 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js
index eb06ab96ddcb09dff3b40eed5e6f81e85c0e750a..9b308dd2a1e0a98c8c372ba8b66bfaffe74c9870 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-alt.js
@@ -95,14 +95,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
index 6ac29798eb6a329716a84c2a3c8dca19716c97a8..77d3e9e6f02229966f144abe5c8e2186bc717984 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
@@ -89,14 +89,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js
index 4a717a34d0347be297397a33734fdbce156bfacc..30c955d44d247b72389159435fa92abc9a52048d 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier-initializer.js
@@ -89,14 +89,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js
index 456a141c7ae00a03c5a34ee474651cb45d0d30c3..61f1349e4dc6fc8c30fd8fff6e3da3bae80fd74d 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-privatename-identifier.js
@@ -95,14 +95,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 2ae364efaf122fec5a0c5cf7a189375a375eee2c..423b2460d25d674e92687298f663e2864e559b6f 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  static async m() { return 42; } static async #$(value) {
+  static async m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,24 +111,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
index 7a2022940828d83ac68fba47ab3b0327e21745c2..bc70b593d5d9cf6b18cb3f51f7478ecc066cbe72 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
index cd55d42a016348619354316788a6265fd7b7e7d9..7e15960948e79142c33038d224eecb6b5cb72200 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -111,24 +111,34 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
index 8723f43953ecaac96db097ff6dad6abcfc2a86cc..60781e46e38fdc256bbb9f81669d9e99e8091ac2 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
@@ -111,25 +111,35 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
index f8b8fbb1200ed121a515fc769d7374853bf28cab..b6e85b8bfc7ea89fd05703e5ae5db9883522ad64 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,13 +111,23 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
index eaa3d8e0827a9b141cf0a4d3838a2ce391f8992a..204363818c65e21a6351bfd9234a8ed4e088610c 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
index a47214d97224dec5feb7c756938fd378d8e9c4ae..db82dc2e67fe8457384ccda63ab877443a44cb07 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
@@ -108,14 +108,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js
index 5519040ed40ceaca4eb9a5e59a26d207ac59db24..32f0f982b83a494d6ecfaf31e7d0acbc4ef4b752 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-method-privatename-identifier.js
@@ -108,14 +108,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
index 424a78f852749d449059007bdf8dd57bbfd25958..9caeb56475fe17786ad1710f4e8257d7d8d9fd1b 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
index 8b3699533cb3f5b8f40a33cf175f1f690924799d..c7818f8c117b7181f9752307c24402932e1c17e6 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
index 7a9b92ba261d11e69478ce16b34492492743a799..2ce91412d6cf8dfc1318409ff8da776491b71f11 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 883090c62550235745406b1cf29e0b0b5352968f..5ccfeca611c95e4f0ccf5806ac32c2b789031496 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,14 +90,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
index f290fda1c20b39e7fc55958cbc7c42dc2e14c4b6..05261823dea8080777e83a6e19311d88148597fd 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -90,14 +90,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
index ea5be51cc44491b03c95244a8e44e79dad07d400..fdf2aabb54a93188474e389aa01d4d98bccace8b 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
@@ -90,14 +90,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js
index bbf4349800b53a52c5894ad54c4a83a60f4717fa..7ec3da6d46ad20e5a02569e1a08bb559bceb0502 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-rs-static-privatename-identifier.js
@@ -96,14 +96,24 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-static-private-fields.js b/test/language/statements/class/fields-after-same-line-static-async-method-static-private-fields.js
index e77b50da511ccae4d15c0e1a3baf57e65ff13851..16407a7f3f8376f072efe54416b425adaab77749 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-static-private-fields.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-static-private-fields.js
@@ -47,23 +47,33 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe2388d05e195d0b3182dcaf94180e33b76d46cf
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods-with-fields.js
@@ -0,0 +1,97 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-static-async-method.template
+/*---
+description: static private methods with fields (field definitions after a static async method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static async m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods.js b/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods.js
index 755b850bd186f85d3b6ef1ef7dc52d2172273532..43c40f9713646b0d4490ca87e8ccf033b728dd14 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  static async m() { return 42; } static #xVal; static #yVal;
+  static async m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,23 +51,33 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+C.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-C.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-async-method-string-literal-names.js b/test/language/statements/class/fields-after-same-line-static-async-method-string-literal-names.js
index 4ff9e092a818ed58f2d140e7f0abee08dc429097..17b011aea6578e87fe276cb5af3487be2cdef142 100644
--- a/test/language/statements/class/fields-after-same-line-static-async-method-string-literal-names.js
+++ b/test/language/statements/class/fields-after-same-line-static-async-method-string-literal-names.js
@@ -38,46 +38,56 @@ verifyProperty(C, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 400d167e2b042221619b1c6aaa6220f4442d29b2..217d5681aa67ebb1251ba57badcfa4d9d513cb38 100644
--- a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  static *m() { return 42; } static async #$(value) {
+  static *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
index 6880c808e9c678d03ae2705dfe0cdaa04c08db56..04ab8befe4cedbed330bcfbb03fa7e15c4b3ec9c 100644
--- a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
index bf3f71dadaf0c04330e6eb7466c7b56e27b4821f..a4137a87fc7ad317672eefc3d20183e5e5aeec01 100644
--- a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
index e9ab085db6e6a0a769107775bbae8295899b640f..3e0274bd1f843af0ddabac273fd0a85ea6a3c4d5 100644
--- a/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods-with-fields.js b/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..ccf91c4410733bd1cc863b8f6509649d7402b484
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-static-gen.template
+/*---
+description: static private methods with fields (field definitions after a static generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, generators, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods.js b/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods.js
index 77a4f80c9a698d28962e43ad960164934a7bc939..cec611b5ff54669834c4df4214036af013080aac 100644
--- a/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods.js
+++ b/test/language/statements/class/fields-after-same-line-static-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  static *m() { return 42; } static #xVal; static #yVal;
+  static *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 2766d3c61e254a5111d7950cda30e75d3618af3e..ad5d3fee90561587d527ed77d51cd294d402b0e9 100644
--- a/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  static m() { return 42; } static async #$(value) {
+  static m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
index aaaf0f82d5ae9b0c3fbd214fa91b08bdcf03d162..20506e588497de0d241e3598f944daf34ff8ecd1 100644
--- a/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
index b8edca96f4e7a9648b07dd19890b483e42234551..7d9a95c32299e14d33d088791f2b9de2f03be725 100644
--- a/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
index eb84e88ae7cfa96b72ec035a32d552d486652308..5379980cb330616fd563ae9cb1c23bfece5ed1f6 100644
--- a/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-after-same-line-static-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-after-same-line-static-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..35f6c681dccee5fd451145d9e89e37ad97d43ce0
--- /dev/null
+++ b/test/language/statements/class/fields-after-same-line-static-method-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-static-method.template
+/*---
+description: static private methods with fields (field definitions after a static method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-after-same-line-static-method-static-private-methods.js b/test/language/statements/class/fields-after-same-line-static-method-static-private-methods.js
index 8c13b7e74f93e9799695f022270b117ba859e0d8..a091055b749f507bb22c90faf1d3205a96bfa5c3 100644
--- a/test/language/statements/class/fields-after-same-line-static-method-static-private-methods.js
+++ b/test/language/statements/class/fields-after-same-line-static-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  static m() { return 42; } static #xVal; static #yVal;
+  static m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 688ee936d3667f7642f0e32393253ea1b5d2bcc9..baa3fefd448bdbddd5ec2d5403f80cc3e67aef84 100644
--- a/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -63,43 +63,43 @@ info: |
 class C {
   foo = "foobar";
   m() { return 42 }
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
index d124b7bb7028f932aee977409646522c7cb1e973..ee2add88630b083290a008ef79e3fb735cf91e67 100644
--- a/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -64,42 +64,42 @@ class C {
   foo = "foobar";
   m() { return 42 }
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
index b5dad58cf64ccfdc34370c251a035f9a41df154b..390e76a1168662186017f9322d8ae527cd57f364 100644
--- a/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -64,42 +64,42 @@ class C {
   foo = "foobar";
   m() { return 42 }
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js
index 65606f39954c132639623bb4e6954a9733a4f8b1..be8eaf19d72d12ad5d47a0d7e9b3ce28653ce177 100644
--- a/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-multiple-definitions-rs-static-generator-method-privatename-identifier.js
@@ -64,42 +64,42 @@ class C {
   foo = "foobar";
   m() { return 42 }
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
   m2() { return 39 }
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-definitions-static-private-methods-with-fields.js b/test/language/statements/class/fields-multiple-definitions-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..4676833aa8ba0864e1dca0a9088472e9aacd97d5
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-definitions-static-private-methods-with-fields.js
@@ -0,0 +1,119 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-multiple-definitions.template
+/*---
+description: static private methods with fields (multiple fields definitions)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  foo = "foobar";
+  m() { return 42 }
+  static #xVal; static #yVal
+  m2() { return 39 }
+  bar = "barbaz";
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-multiple-definitions-static-private-methods.js b/test/language/statements/class/fields-multiple-definitions-static-private-methods.js
index df86d9893d65901e8d7332d715e2c11f7ac26fc4..5e551cb57a706bd116581230813c1b5f32bb493e 100644
--- a/test/language/statements/class/fields-multiple-definitions-static-private-methods.js
+++ b/test/language/statements/class/fields-multiple-definitions-static-private-methods.js
@@ -27,19 +27,17 @@ info: |
 class C {
   foo = "foobar";
   m() { return 42 }
-  static #xVal; static #yVal
+  
   m2() { return 39 }
   bar = "barbaz";
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -91,18 +89,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 09ade3dbfcd051f2b9096cab43311e0ebd739752..b6731aa8507eb84cb7d95d08e1f1b171f56a0980 100644
--- a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,43 +61,43 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
index 356fd5374830f969a37dda51529b1aa4baac955c..0e3a704d677d928ea52fdb65f3f543760453535b 100644
--- a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -62,42 +62,42 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
index a12442c283e7c82895d1d826e3662ad3f0ca3dc0..3f4f52a932fb0c543a0cc81fbbf196cdf062e5ca 100644
--- a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,42 +62,42 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
index 346e65cdcf7f6bcbd2b63360df3befd760666397..44be3133276fe771e0e9d3aef5f50fecddc67ec9 100644
--- a/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
@@ -62,42 +62,42 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
   foo = "foobar"
   bar = "barbaz";
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods-with-fields.js b/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6a64bcfc2476af8a5b3b3b108cc593c30137d7e
--- /dev/null
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods-with-fields.js
@@ -0,0 +1,97 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-multiple-stacked-definitions.template
+/*---
+description: static private methods with fields (multiple stacked fields definitions through ASI)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal
+  foo = "foobar"
+  bar = "barbaz";
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods.js b/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods.js
index 9e38dfbc9112705d4f04a321d7615748cde876f2..9a0d29ae31cc044dafcf43c8474e16e74380058b 100644
--- a/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods.js
+++ b/test/language/statements/class/fields-multiple-stacked-definitions-static-private-methods.js
@@ -25,19 +25,17 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal
+  
   foo = "foobar"
   bar = "barbaz";
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -69,18 +67,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 605fb4537e7350e637758bd30eef340fdb1ff458..8d3c7417661e62de27fa7b2748495fbc637c4ca2 100644
--- a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
   m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 239d4919c1756d6f9b77bd8945f484ca4a08a90f..a3a80442c18e349ff2ff7dfcf6a6396dac87ec06 100644
--- a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
   m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 7239d18edc9af96101f638c16a3b7ff49c523d3a..0105dbdcd12f4f529a80151e52ae557f016a0b5a 100644
--- a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
index bca48ba4d3a4e07657aa531234f077958e512e07..f8f665aaed49e8fc6a97d8a9d8365bc437cca849 100644
--- a/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ccbc23ba9854f732dd58ce9367f281722c0d605
--- /dev/null
+++ b/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-new-no-sc-line-method.template
+/*---
+description: static private methods with fields (field definitions followed by a method in a new line without a semicolon)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal
+  m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods.js b/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods.js
index 6b444eb32649c8c57ab9c059b857f70cfebe31d0..5ab1222b9ad09123bebbe168569cffa47323ae10 100644
--- a/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods.js
+++ b/test/language/statements/class/fields-new-no-sc-line-method-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal
+  
   m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -56,18 +54,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index e078209aa47f46c39f7477d47e93517a0dafe1aa..7faf2d03b80f13a6b0b83eedcc92f034150b2c9a 100644
--- a/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
   *m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 12b2d42c5e88bccc6257fcc1a0983548432c9ebb..dce0673774ef4f079d04857c45ee10e74d68b21c 100644
--- a/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
   *m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index c52d4f24fac23286641bf53715bb53cb9cdd8e4e..157c9c25d2ef7fde44471493db8f76697a2a87a9 100644
--- a/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
   *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
index 1f5549752aceadc0125a06b7b2c8d56808b08d50..5be0a510d7dc65096f959470d2bc0495ee879477 100644
--- a/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
   *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-gen-static-private-methods-with-fields.js b/test/language/statements/class/fields-new-sc-line-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..1239f224f59418a22fb6579e3fcfba9a56d57d4e
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-gen-static-private-methods-with-fields.js
@@ -0,0 +1,85 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-new-sc-line-generator.template
+/*---
+description: static private methods with fields (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal;
+  *m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-new-sc-line-gen-static-private-methods.js b/test/language/statements/class/fields-new-sc-line-gen-static-private-methods.js
index c1bf2164e0a3dc5ce9d2d46fb3a2fdf8480c2e95..553f28223e0ef1ed8dc30de4abf0ebda4cfb9d5c 100644
--- a/test/language/statements/class/fields-new-sc-line-gen-static-private-methods.js
+++ b/test/language/statements/class/fields-new-sc-line-gen-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal;
+  ;
   *m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -56,18 +54,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 3b129d8707f06be28c307b79b6ef7a8da1967865..758b553478153472aff5b1b7171ac078550f1596 100644
--- a/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
   m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index deac127cb8f138fa6ff7f4f015fdb6d41d4edeb4..26faa8654c61d17650716cf4c0905f6172238b7e 100644
--- a/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
   m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 00afe0eeb18332651dd024c8d2e74b61293349df..f3affd4f37d5b7e66ad0746a97da8cd491fae84e 100644
--- a/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js
index f1563bbf9882e1adb762ce5ca4404ffe11786ddb..05daed590ef7fb35e33420db8ebaf088b9c0f074 100644
--- a/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-new-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
   m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-new-sc-line-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-new-sc-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..8951d66b86cc4d438cd77e33c227dcef63fbb171
--- /dev/null
+++ b/test/language/statements/class/fields-new-sc-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-new-sc-line-method.template
+/*---
+description: static private methods with fields (field definitions followed by a method in a new line with a semicolon)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal;
+  m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-new-sc-line-method-static-private-methods.js b/test/language/statements/class/fields-new-sc-line-method-static-private-methods.js
index eb7d9e137e9f8afa41d276a2a60e024a7f2a4f98..52fce5b9d769fdd009620a047c52467c065f7406 100644
--- a/test/language/statements/class/fields-new-sc-line-method-static-private-methods.js
+++ b/test/language/statements/class/fields-new-sc-line-method-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal;
+  ;
   m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -56,18 +54,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 4ca30010481998fe2811ca80fcc32d071ef46aa8..816836e01d8de5b608008367d000e8ffa5aebb0e 100644
--- a/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -60,41 +60,41 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js
index 4d384515f0de5b7b893bc29157660f4e3d2885f2..33a5f10f93fcb2f088d323cc4e9f9b2f0736ea9b 100644
--- a/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-regular-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -61,40 +61,40 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
index 87235f63cb32a1f0d75ce1f061d4fc2c39611569..7dc79244d8a6e498df9ea14039a452c1b4e9450d 100644
--- a/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -61,40 +61,40 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js
index f2444b4a57240aaabef16d79e8b15acfe2255acd..259d0a31f75a1455b58db8c4ac5661ed8db58cb0 100644
--- a/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-regular-definitions-rs-static-generator-method-privatename-identifier.js
@@ -61,40 +61,40 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-regular-definitions-static-private-methods-with-fields.js b/test/language/statements/class/fields-regular-definitions-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..680fb71fa326aef349dafaf724d897d5fa085f06
--- /dev/null
+++ b/test/language/statements/class/fields-regular-definitions-static-private-methods-with-fields.js
@@ -0,0 +1,72 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-regular-definitions.template
+/*---
+description: static private methods with fields (regular fields defintion)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+var c = new C();
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-regular-definitions-static-private-methods.js b/test/language/statements/class/fields-regular-definitions-static-private-methods.js
index 74b7858c7b6cb4e71b7131cb6b49d54f4eb69ea8..801cca5c01fe3bccc261021ced4f60ac35ce7f73 100644
--- a/test/language/statements/class/fields-regular-definitions-static-private-methods.js
+++ b/test/language/statements/class/fields-regular-definitions-static-private-methods.js
@@ -24,17 +24,15 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal
+  
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -44,18 +42,18 @@ class C {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-same-line-async-gen-computed-names.js b/test/language/statements/class/fields-same-line-async-gen-computed-names.js
index 9dd54fa73993ef14af071e5a80bb84bcbfd6fb3b..31c39e343a49f0dfda8f9cd9fc082af4d328ab1d 100644
--- a/test/language/statements/class/fields-same-line-async-gen-computed-names.js
+++ b/test/language/statements/class/fields-same-line-async-gen-computed-names.js
@@ -39,41 +39,51 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-computed-symbol-names.js b/test/language/statements/class/fields-same-line-async-gen-computed-symbol-names.js
index 948d23c827140231347b206cdc5497557ba73196..6e0f597841990fa6eafa30d551aa70560886a585 100644
--- a/test/language/statements/class/fields-same-line-async-gen-computed-symbol-names.js
+++ b/test/language/statements/class/fields-same-line-async-gen-computed-symbol-names.js
@@ -40,35 +40,45 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 6bd67d046c5ca9effc3924669f6e3e62e96e2d52..95cfd47b363bddb98e35b4b6e159e5019a406196 100644
--- a/test/language/statements/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/fields-same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,12 +98,22 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-literal-names.js b/test/language/statements/class/fields-same-line-async-gen-literal-names.js
index 4ca55d8d9612c2b47e27a722b6622020b1b835fa..1c9c16471e9b539ce202df2b8367db0c0cf4ff60 100644
--- a/test/language/statements/class/fields-same-line-async-gen-literal-names.js
+++ b/test/language/statements/class/fields-same-line-async-gen-literal-names.js
@@ -40,38 +40,48 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-private-names.js b/test/language/statements/class/fields-same-line-async-gen-private-names.js
index adbd03e6c6237a78331637f7a380263bbc167932..97384185847fccdaef41c86c0f8bff8eaea23a35 100644
--- a/test/language/statements/class/fields-same-line-async-gen-private-names.js
+++ b/test/language/statements/class/fields-same-line-async-gen-private-names.js
@@ -47,24 +47,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-c.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier-initializer.js b/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier-initializer.js
index 6906aadfa1cc01884ff322fd24e3ee40be9449ed..2b070254b3dc29efe5965d593a7584c3ab9a38dc 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier-initializer.js
@@ -74,14 +74,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier.js
index 8db7ab527ce630f24a6bc28da797ed3bd25d13ef..78359bed27f4a539fc52b2f3b17323f88806abe4 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-field-identifier.js
@@ -74,21 +74,31 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js
index 316381c808b497e4889ddf14030746295135d395..8e51e991170a5cb57ab4532cb0b00cb2fa80fabb 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-alt.js
@@ -95,15 +95,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js
index a2d85fa4765e213c544c829764716272fe493101..147e348503ecd9190916955d62bb67b60d513572 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -89,15 +89,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js
index 71ad00009a5668f94932d9e42f4ceecb95e7e522..62c45ace28dea571cc6e0bd4507513fc989a2ed5 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier-initializer.js
@@ -89,15 +89,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier.js
index 992843e45c49e418404cfaee5874fb8f0c201666..d6ba67cd6045e7af0ede4b0b950ea7258640f700 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-privatename-identifier.js
@@ -95,15 +95,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 263742e08c18e10487ffa6dcc525179051c1fb69..eee91de28fe57a62e8457a2d9f582e0b6200154e 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  async *m() { return 42; } static async #$(value) {
+  async *m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
index c63da90036eaae82283039211522cfde4b2a5649..5c5d6ef15105f199c1cb2e854c47d4c1e017e15d 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   async *m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,26 +111,36 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
index d5b17a2aa218c1784834259ee4f7cdff5e3983b1..b50c4363dbde789d115daa7f12dff5d4ec86fc0e 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js
index 448e95ffdfa458d6b394fb224cc7812505a6e1be..88fcb8cead4878df93a3b60aa1ea26ba9984e832 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-async-method-privatename-identifier.js
@@ -111,26 +111,36 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index 8557f9e15566e67baed8d81edead7588a0930363..a9fdec76f64146caebaf2b3be08887310e0aa13c 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js
index 2310df37d422de59645e96a5fdf0704e8bb9cda1..182d6b5aa18989dfd81d43ccbc988976536a950b 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   async *m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,15 +111,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js
index 3a5dbc94e589a6cbd90b084247a65266aed55aba..fc25be8434bcbd7d581e7a569819162b22e0f4cf 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -108,15 +108,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js
index 34822c8641c3d81d51e68bc8982625ccdeeeeb25..6ae403902f983ad7b80665649814b9763c844878 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-method-privatename-identifier.js
@@ -108,15 +108,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index ff06256006bcc2879d15550bb77bac50dd813e99..efc03fdd697f08f4c2c3b583de8b9bec05a8eb94 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js
index 5c9a05df8eb552709d2fcfd170496b2bd6d21de8..c4a7cfee57e0ec37da21621a58e486dc07a466e1 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-alt.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js
index 64fa0b3f172f3eedf0497dda9bee815e3091cf19..668651c0218a32f88492e5f171e6c55fc9352c5e 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 832d2cfc7923f32443b42a2d42325f485fbc9f14..5533fb009e792052a7676a2dd38acfa5cdca6ed2 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,15 +90,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
index 15d9c9b353d9d317c7ed01e39572b0f1df7e3eef..39da868e54bab6272e934a4a4549fe182ac52e3e 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -90,15 +90,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js
index c5b703caea3fed165f852ef60a153cb6b57729ad..73110c59fe4d8aba15e1ab6b29abcfa0665916ac 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier-initializer.js
@@ -90,15 +90,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier.js
index 2c2149d586ce6aa2cacd4bc9f86efd98e7317c0e..1ef59ac397fe6daa8afe0eff4b97a42764bd1381 100644
--- a/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-gen-rs-static-privatename-identifier.js
@@ -96,15 +96,25 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-static-private-fields.js b/test/language/statements/class/fields-same-line-async-gen-static-private-fields.js
index 25507fab392c8e855b4d68c8620449eb536f4d39..7760041b8efb2319ce361b3f1c66563e87b983da 100644
--- a/test/language/statements/class/fields-same-line-async-gen-static-private-fields.js
+++ b/test/language/statements/class/fields-same-line-async-gen-static-private-fields.js
@@ -47,24 +47,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-c.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-static-private-methods-with-fields.js b/test/language/statements/class/fields-same-line-async-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..a3729713586a3a02f3e8d24dee7ab6384d82754c
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-gen-static-private-methods-with-fields.js
@@ -0,0 +1,98 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-async-gen.template
+/*---
+description: static private methods with fields (field definitions after an async generator in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-iteration]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  async *m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-static-private-methods.js b/test/language/statements/class/fields-same-line-async-gen-static-private-methods.js
index 56dec2a2eee2b06be0aa3d54fa01f43e816e8690..e8a86da1842aa01b14f53c6a462029fef8af9dcb 100644
--- a/test/language/statements/class/fields-same-line-async-gen-static-private-methods.js
+++ b/test/language/statements/class/fields-same-line-async-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  async *m() { return 42; } static #xVal; static #yVal;
+  async *m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,24 +51,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+c.m().next().then(function(v) {
+  assert.sameValue(v.value, 42);
+  assert.sameValue(v.done, true);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-c.m().next().then(function(v) {
-  assert.sameValue(v.value, 42);
-  assert.sameValue(v.done, true);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-gen-string-literal-names.js b/test/language/statements/class/fields-same-line-async-gen-string-literal-names.js
index 759eb62bd115735555a7717b43f55a45392d1d82..fa049206fd04417df117f0bad6d9306114dca098 100644
--- a/test/language/statements/class/fields-same-line-async-gen-string-literal-names.js
+++ b/test/language/statements/class/fields-same-line-async-gen-string-literal-names.js
@@ -38,47 +38,57 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-computed-names.js b/test/language/statements/class/fields-same-line-async-method-computed-names.js
index f68257e2a005e88893fd3b7e6ce164f3db1ed2d5..63765da65213968bc78833f43abe1ce21ef3d66f 100644
--- a/test/language/statements/class/fields-same-line-async-method-computed-names.js
+++ b/test/language/statements/class/fields-same-line-async-method-computed-names.js
@@ -39,40 +39,50 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
-
-verifyProperty(c, "10", {
-  value: "meep",
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
-
-verifyProperty(c, "not initialized", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+
+    verifyProperty(c, "10", {
+      value: "meep",
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+
+    verifyProperty(c, "not initialized", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-computed-symbol-names.js b/test/language/statements/class/fields-same-line-async-method-computed-symbol-names.js
index 11eda8bd65145c86b7ee4d426ed1bdb9fe7c8d25..1769248f7b5195f39c76d673b62e29c80a415ece 100644
--- a/test/language/statements/class/fields-same-line-async-method-computed-symbol-names.js
+++ b/test/language/statements/class/fields-same-line-async-method-computed-symbol-names.js
@@ -40,34 +40,44 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
-
-verifyProperty(c, x, {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
-
-verifyProperty(c, y, {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
-
 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(Object.hasOwnProperty.call(C.prototype, x), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+
+    verifyProperty(c, x, {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+
+    verifyProperty(c, y, {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index b1a083f770c776d40fc64028b6f915f1d7abf843..3a37d59e2a80a36f71eecb427914b960e7789814 100644
--- a/test/language/statements/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/fields-same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -98,11 +98,21 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.o(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
 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.o(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-literal-names.js b/test/language/statements/class/fields-same-line-async-method-literal-names.js
index a479fdd3c3b007b5f10f1ecbe1e0a44ffe407fb6..87c14e1d956a92631108eb8e014319324d5f110c 100644
--- a/test/language/statements/class/fields-same-line-async-method-literal-names.js
+++ b/test/language/statements/class/fields-same-line-async-method-literal-names.js
@@ -40,37 +40,47 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: fn,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: fn,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-private-names.js b/test/language/statements/class/fields-same-line-async-method-private-names.js
index 9f58eb22d2beef11173e9f7f7d8527e618f4e5a8..8d412af6c46f12ff4316501b010d51e4dcad4685 100644
--- a/test/language/statements/class/fields-same-line-async-method-private-names.js
+++ b/test/language/statements/class/fields-same-line-async-method-private-names.js
@@ -47,23 +47,33 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(c.x(), 42, "test 7");
-assert.sameValue(c.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(c.x(), 42, "test 7");
+    assert.sameValue(c.y(), 43, "test 8");
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-field-identifier-initializer.js b/test/language/statements/class/fields-same-line-async-method-rs-field-identifier-initializer.js
index e1b07b248c9cb8b4359e56f0e96a2df6035b15f7..de1f6e360a97a7d503916395ce6796eb8fc3b452 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-field-identifier-initializer.js
@@ -74,13 +74,23 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-field-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-field-identifier.js
index 9ab607ddbfb8c46ae86e1ce919bc2a800e703515..8b95cb7b07dd6ce19fddd07fe5ddaff4496b7469 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-field-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-field-identifier.js
@@ -74,20 +74,30 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-c.$ = 1;
-c._ = 1;
-c.\u{6F} = 1;
-c.\u2118 = 1;
-c.ZW_\u200C_NJ = 1;
-c.ZW_\u200D_J = 1;
-
-assert.sameValue(c.$, 1);
-assert.sameValue(c._, 1);
-assert.sameValue(c.\u{6F}, 1);
-assert.sameValue(c.\u2118, 1);
-assert.sameValue(c.ZW_\u200C_NJ, 1);
-assert.sameValue(c.ZW_\u200D_J, 1);
-
 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')
+      }
+    }
+    c.$ = 1;
+    c._ = 1;
+    c.\u{6F} = 1;
+    c.\u2118 = 1;
+    c.ZW_\u200C_NJ = 1;
+    c.ZW_\u200D_J = 1;
+
+    assert.sameValue(c.$, 1);
+    assert.sameValue(c._, 1);
+    assert.sameValue(c.\u{6F}, 1);
+    assert.sameValue(c.\u2118, 1);
+    assert.sameValue(c.ZW_\u200C_NJ, 1);
+    assert.sameValue(c.ZW_\u200D_J, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-alt.js
index a0819035aad7b52b017364f2897a772891a641ff..e91deb5ad06e6e27960ecac22b67c83cb2314ebb 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-alt.js
@@ -95,14 +95,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.℘(1), 1);
-assert.sameValue(c.ZW_‌_NJ(1), 1);
-assert.sameValue(c.ZW_‍_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.℘(1), 1);
+    assert.sameValue(c.ZW_‌_NJ(1), 1);
+    assert.sameValue(c.ZW_‍_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js
index 79ade95804cf59a7c7707e94d3ac2f0361c3a694..162cbf1d4dae390923b0259366d114d7423ba06a 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer-alt.js
@@ -89,14 +89,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.℘(), 1);
-assert.sameValue(c.ZW_‌_NJ(), 1);
-assert.sameValue(c.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.℘(), 1);
+    assert.sameValue(c.ZW_‌_NJ(), 1);
+    assert.sameValue(c.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js
index 35db4d8d0a29bf25421a4f45a08cd54667673c52..f6807a62ecc83cf87b3f8e7be8a77b0c589432ca 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier-initializer.js
@@ -89,14 +89,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(), 1);
-assert.sameValue(c._(), 1);
-assert.sameValue(c.\u{6F}(), 1);
-assert.sameValue(c.\u2118(), 1);
-assert.sameValue(c.ZW_\u200C_NJ(), 1);
-assert.sameValue(c.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(c._(), 1);
+    assert.sameValue(c.\u{6F}(), 1);
+    assert.sameValue(c.\u2118(), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(), 1);
+    assert.sameValue(c.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier.js
index 0ff930c120efa315286cc393556f71c18d406a9b..9b6602c4ba5f81d3b4b0c4a0148552478b8c7a50 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-privatename-identifier.js
@@ -95,14 +95,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(c.$(1), 1);
-assert.sameValue(c._(1), 1);
-assert.sameValue(c.\u{6F}(1), 1);
-assert.sameValue(c.\u2118(1), 1);
-assert.sameValue(c.ZW_\u200C_NJ(1), 1);
-assert.sameValue(c.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(c._(1), 1);
+    assert.sameValue(c.\u{6F}(1), 1);
+    assert.sameValue(c.\u2118(1), 1);
+    assert.sameValue(c.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(c.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 1807d1e71cee63151bd04c66bace977a4d97cb46..9439312b16151321588af4dc057f2fd511ee6694 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  async m() { return 42; } static async #$(value) {
+  async m() { return 42; } static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
@@ -111,24 +111,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.o(1).next(),
-  C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.o(1).next(),
+      C.℘(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1).next(), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
index 1d10947d305a64176ced1c52b96a7b5322670606..1a445b93e97bda380c14137c28f5b6d5fdefe013 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   async m() { return 42; } static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1).next(),
-  C._(1).next(),
-  C.\u{6F}(1).next(),
-  C.\u2118(1).next(),
-  C.ZW_\u200C_NJ(1).next(),
-  C.ZW_\u200D_J(1).next(),
-]).then(results => {
-
-  assert.sameValue(results[0].value, 1);
-  assert.sameValue(results[1].value, 1);
-  assert.sameValue(results[2].value, 1);
-  assert.sameValue(results[3].value, 1);
-  assert.sameValue(results[4].value, 1);
-  assert.sameValue(results[5].value, 1);
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1).next(),
+      C._(1).next(),
+      C.\u{6F}(1).next(),
+      C.\u2118(1).next(),
+      C.ZW_\u200C_NJ(1).next(),
+      C.ZW_\u200D_J(1).next(),
+    ]).then(results => {
+
+      assert.sameValue(results[0].value, 1);
+      assert.sameValue(results[1].value, 1);
+      assert.sameValue(results[2].value, 1);
+      assert.sameValue(results[3].value, 1);
+      assert.sameValue(results[4].value, 1);
+      assert.sameValue(results[5].value, 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
index bf618bbd90b253c6d9a55e9a08e20799609a698d..cde56325501981571ac5ed8938d4bcc43d7895f7 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -111,24 +111,34 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.o(1),
-  C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-  C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
-
-}, $DONE).then($DONE, $DONE);
-
 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')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.o(1),
+      C.℘(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‌_NJ(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+      C.ZW_‍_J(1), // DO NOT CHANGE THE NAME OF THIS FIELD
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js
index 021a6ac3a53386a08de9eaa3d2c36982216d835f..0228f8aca8b378457daf5dd79a8f727acb256127 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-async-method-privatename-identifier.js
@@ -111,25 +111,35 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-Promise.all([
-  C.$(1),
-  C._(1),
-  C.\u{6F}(1),
-  C.\u2118(1),
-  C.ZW_\u200C_NJ(1),
-  C.ZW_\u200D_J(1),
-]).then(results => {
-
-  assert.sameValue(results[0], 1);
-  assert.sameValue(results[1], 1);
-  assert.sameValue(results[2], 1);
-  assert.sameValue(results[3], 1);
-  assert.sameValue(results[4], 1);
-  assert.sameValue(results[5], 1);
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-}, $DONE).then($DONE, $DONE);
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    Promise.all([
+      C.$(1),
+      C._(1),
+      C.\u{6F}(1),
+      C.\u2118(1),
+      C.ZW_\u200C_NJ(1),
+      C.ZW_\u200D_J(1),
+    ]).then(results => {
+
+      assert.sameValue(results[0], 1);
+      assert.sameValue(results[1], 1);
+      assert.sameValue(results[2], 1);
+      assert.sameValue(results[3], 1);
+      assert.sameValue(results[4], 1);
+      assert.sameValue(results[5], 1);
+
+    }, $DONE).then($DONE, $DONE);
 
+  }
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
index f20de2c3e529fd637483157900e3905971babcb3..d5a59e4b6f4c9b54704ddb421e9049c365c89a56 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
@@ -111,13 +111,23 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.o(1).next().value, 1);
-assert.sameValue(C.℘(1).next().value, 1);
-assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_‍_J(1).next().value, 1);
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.o(1).next().value, 1);
+    assert.sameValue(C.℘(1).next().value, 1);
+    assert.sameValue(C.ZW_‌_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_‍_J(1).next().value, 1);
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js
index f6815bb66aef51a580f7753b0bd30dca00ff8ce5..d6121a144f00638a5c6311257ff77c37b326893e 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   async m() { return 42; } static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
@@ -111,14 +111,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1).next().value, 1);
-assert.sameValue(C._(1).next().value, 1);
-assert.sameValue(C.\u{6F}(1).next().value, 1);
-assert.sameValue(C.\u2118(1).next().value, 1);
-assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
-assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
-
-
 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.$(1).next().value, 1);
+    assert.sameValue(C._(1).next().value, 1);
+    assert.sameValue(C.\u{6F}(1).next().value, 1);
+    assert.sameValue(C.\u2118(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1).next().value, 1);
+    assert.sameValue(C.ZW_\u200D_J(1).next().value, 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js
index ce2eda176b162196e985ff32ab252be54928c2ac..f28968fb8023f3aab0422c0dc41a3c4325cb941a 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier-alt.js
@@ -108,14 +108,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js
index 2ab524d63cfa058cd25dac58cdbfa1283180cad9..3f2b28f82199453bf984d07cb53e56515c0b34b1 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-method-privatename-identifier.js
@@ -108,14 +108,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
index b24220655b5e7e84dba93b42030ee1869cc52d44..4e0dafefa2c7455ed9b01e1e669f2cd44571788d 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js
index 582e865cd889f76d3b8960399566c2018973a04b..a1ab3858a93aa18e8b23e2210e2cd13d2b18fbba 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-alt.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.o(1), 1);
-assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
-assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.o(1), 1);
+    assert.sameValue(C.℘(1), 1);      // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‌_NJ(1), 1); // DO NOT CHANGE THE NAME OF THIS FIELD
+    assert.sameValue(C.ZW_‍_J(1), 1);  // DO NOT CHANGE THE NAME OF THIS FIELD
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js
index f5b8fc84c5b4bbdc656b7a5aac9c76dc042b8966..ad18be8aebadb6e4f6be31dd98cb9d0b57ea6024 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-by-classname.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index ea9823cf4b3e2f528ccff3bf00ad90d33568938f..20e06d2448243e48439d00b4b431de40a49499c8 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -90,14 +90,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
index ae9e7f7b81ebcc15afa9ea5bd53f5507a82d9701..49fa983335952c31709e62c20f3bc00680ac656e 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -90,14 +90,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.℘(), 1);
-assert.sameValue(C.ZW_‌_NJ(), 1);
-assert.sameValue(C.ZW_‍_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.℘(), 1);
+    assert.sameValue(C.ZW_‌_NJ(), 1);
+    assert.sameValue(C.ZW_‍_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js
index 69aa0a43fc3cbb528164d7579d094c3bb79dfed7..c93137d8640ac49ec156320967b42b80c25237fd 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier-initializer.js
@@ -90,14 +90,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(), 1);
-assert.sameValue(C._(), 1);
-assert.sameValue(C.\u{6F}(), 1);
-assert.sameValue(C.\u2118(), 1);
-assert.sameValue(C.ZW_\u200C_NJ(), 1);
-assert.sameValue(C.ZW_\u200D_J(), 1);
-
-
 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.$(), 1);
+    assert.sameValue(C._(), 1);
+    assert.sameValue(C.\u{6F}(), 1);
+    assert.sameValue(C.\u2118(), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(), 1);
+    assert.sameValue(C.ZW_\u200D_J(), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier.js b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier.js
index 0508e4fc0e54828af2a76289f02b89fc4f800133..bcd31bb1cfc941888e11794e24d04d712960b33f 100644
--- a/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-async-method-rs-static-privatename-identifier.js
@@ -96,14 +96,24 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(C.$(1), 1);
-assert.sameValue(C._(1), 1);
-assert.sameValue(C.\u{6F}(1), 1);
-assert.sameValue(C.\u2118(1), 1);
-assert.sameValue(C.ZW_\u200C_NJ(1), 1);
-assert.sameValue(C.ZW_\u200D_J(1), 1);
-
-
 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.$(1), 1);
+    assert.sameValue(C._(1), 1);
+    assert.sameValue(C.\u{6F}(1), 1);
+    assert.sameValue(C.\u2118(1), 1);
+    assert.sameValue(C.ZW_\u200C_NJ(1), 1);
+    assert.sameValue(C.ZW_\u200D_J(1), 1);
+
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-static-private-fields.js b/test/language/statements/class/fields-same-line-async-method-static-private-fields.js
index 3530b98d0f2d9dd4f93d573ac2105854aeea3f67..a6bfb96c85470acc224304891ed0acd9cc79910e 100644
--- a/test/language/statements/class/fields-same-line-async-method-static-private-fields.js
+++ b/test/language/statements/class/fields-same-line-async-method-static-private-fields.js
@@ -47,23 +47,33 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private fields do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 43, "test 8");
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-same-line-async-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..f068a5af2c54fa951252cffb22e346e509ed788b
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-async-method-static-private-methods-with-fields.js
@@ -0,0 +1,97 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-after-same-line-async-method.template
+/*---
+description: static private methods with fields (field definitions after an async method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  async-functions]
+flags: [generated, async]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  async m() { return 42; } static #xVal; static #yVal;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 13");
+    assert.sameValue(C.y(), 43, "test 14");
+
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+  }
+
+  return Promise.resolve(assertions());
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-static-private-methods.js b/test/language/statements/class/fields-same-line-async-method-static-private-methods.js
index 15a37aa86df5faf156393d3328b33915795d7db4..c267dd141596fc46446c680abc24dc7ecdaef18e 100644
--- a/test/language/statements/class/fields-same-line-async-method-static-private-methods.js
+++ b/test/language/statements/class/fields-same-line-async-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  async m() { return 42; } static #xVal; static #yVal;
+  async m() { return 42; } ;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -53,23 +51,33 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-// Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+c.m().then(function(v) {
+  assert.sameValue(v, 42);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+  function assertions() {
+    // Cover $DONE handler for async cases.
+    function $DONE(error) {
+      if (error) {
+        throw new Test262Error('Test262:AsyncTestFailure')
+      }
+    }
+    // Test the private methods do not appear as properties before set to value
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-// Test if private fields can be sucessfully accessed and set to value
-assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
-// Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+    // Test if private fields can be sucessfully accessed and set to value
+    assert.sameValue(C.x(), 42, "test 7");
+    assert.sameValue(C.y(), 86, "test 8");
 
-c.m().then(function(v) {
-  assert.sameValue(v, 42);
+    // Test the private fields do not appear as properties before after set to value
+    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-async-method-string-literal-names.js b/test/language/statements/class/fields-same-line-async-method-string-literal-names.js
index 31354912ccb78166fb105f175da0c92b01643641..394ca82c162fee2a249cdf145f6d1eeacfb5e818 100644
--- a/test/language/statements/class/fields-same-line-async-method-string-literal-names.js
+++ b/test/language/statements/class/fields-same-line-async-method-string-literal-names.js
@@ -38,46 +38,56 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 }, {restore: true});
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
-
-verifyProperty(c, "a", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
-
-verifyProperty(c, "b", {
-  value: undefined,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
-
-verifyProperty(c, "c", {
-  value: 39,
-  enumerable: true,
-  writable: true,
-  configurable: true
-});
-
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
-
-verifyProperty(c, "d", {
-  value: 42,
-  enumerable: true,
-  writable: true,
-  configurable: 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(Object.hasOwnProperty.call(C.prototype, "a"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+
+    verifyProperty(c, "a", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+
+    verifyProperty(c, "b", {
+      value: undefined,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+
+    verifyProperty(c, "c", {
+      value: 39,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+
+    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
+    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+
+    verifyProperty(c, "d", {
+      value: 42,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+
+  return Promise.resolve(assertions());
 }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 34c52e35bef9105f2c95d205c0d723c9502713f0..ddc2ffc41a24dfb2894665883da2f3367587484c 100644
--- a/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }; *m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index d1bf17f7d03aca9608ecf52c9399d1498c5170d8..df02c740c9c3723c25afa3075da0b1827f272bf8 100644
--- a/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }; *m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index 96c7fd23243388e3566bb733c545b5226f9713eb..098a3c41f3e020d02b9bc3ed0decabb81f688a26 100644
--- a/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }; *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js
index 7487f8a298911afbfd88901d01fa30bce36dfd78..9fe818f02b0f31e3713e110b5c85a7b9ea994532 100644
--- a/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }; *m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-gen-static-private-methods-with-fields.js b/test/language/statements/class/fields-same-line-gen-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..d3ca921528e50c7e02ed19338ccf6fe54802dc43
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-gen-static-private-methods-with-fields.js
@@ -0,0 +1,84 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-same-line-generator.template
+/*---
+description: static private methods with fields (field definitions followed by a generator method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public,
+  generators]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal; *m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-same-line-gen-static-private-methods.js b/test/language/statements/class/fields-same-line-gen-static-private-methods.js
index a1c6037d4ff3b8c66f6fc3238e4154e0b46ed4f7..d07ba26d0db424221d6696c695796c1f43565cd6 100644
--- a/test/language/statements/class/fields-same-line-gen-static-private-methods.js
+++ b/test/language/statements/class/fields-same-line-gen-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal; *m() { return 42; }
+  ; *m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 283f4bb57c439b733426d7ab3dae3baddaad9ac9..710acab0eecb9dd1b87e22195e77cddb29d84839 100644
--- a/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,41 +61,41 @@ info: |
 
 
 class C {
-  static async #$(value) {
+  static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   }; m() { return 42; }
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js
index 9852b31b81416bc60a3665de07a761bdb7e7f1c6..e9227dc9a6e16ed15583649080ea3d909189d1b6 100644
--- a/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   }; m() { return 42; }
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 4db8cae136646c6b4b4a2ccafb3fe1680c2777ad..a653b9444c1d3d3227e67f4ce45795ec05746a91 100644
--- a/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   }; m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js
index d69787b1ddfcfc99c890f828117623f950b39bd6..26f933b6ae7db8b183cacd2a793277d0a5d06af2 100644
--- a/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -62,40 +62,40 @@ info: |
 
 class C {
   static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   }; m() { return 42; }
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-same-line-method-static-private-methods-with-fields.js b/test/language/statements/class/fields-same-line-method-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..7f890e53774329d1a6a13437780659d079a25604
--- /dev/null
+++ b/test/language/statements/class/fields-same-line-method-static-private-methods-with-fields.js
@@ -0,0 +1,83 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-same-line-method.template
+/*---
+description: static private methods with fields (field definitions followed by a method in the same line)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+includes: [propertyHelper.js]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  static #xVal; static #yVal; m() { return 42; }
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+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,
+});
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-same-line-method-static-private-methods.js b/test/language/statements/class/fields-same-line-method-static-private-methods.js
index fd2bf8fd769618c6073168467de70b5c8d2909d1..1ac5dd97506215d8d8eaabfb7c59274b5409d4f1 100644
--- a/test/language/statements/class/fields-same-line-method-static-private-methods.js
+++ b/test/language/statements/class/fields-same-line-method-static-private-methods.js
@@ -25,17 +25,15 @@ info: |
 
 
 class C {
-  static #xVal; static #yVal; m() { return 42; }
+  ; m() { return 42; }
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -55,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
diff --git a/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
index b9c70eec7fbc1b9acdf25c773702f0d1be8ae6b3..c580dd569cbec3561b2ff03b411a29c89de6017a 100644
--- a/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -61,42 +61,42 @@ info: |
 
 class C {
   ;;;;
-  ;;;;;;static async #$(value) {
+  ;;;;;;static async * #$(value) {
     yield await value;
   }
-  static async #_(value) {
+  static async * #_(value) {
     yield await value;
   }
-  static async #o(value) {
+  static async * #o(value) {
     yield await value;
   }
-  static async #℘(value) {
+  static async * #℘(value) {
     yield await value;
   }
-  static async #ZW_‌_NJ(value) {
+  static async * #ZW_‌_NJ(value) {
     yield await value;
   }
-  static async #ZW_‍_J(value) {
+  static async * #ZW_‍_J(value) {
     yield await value;
   };;;;;;;
   ;;;;
-  static async $(value) {
-    yield * await this.#$(value);
+  static get $() {
+   return this.#$;
   }
-  static async _(value) {
-    yield * await this.#_(value);
+  static get _() {
+   return this.#_;
   }
-  static async o(value) {
-    yield * await this.#o(value);
+  static get o() {
+   return this.#o;
   }
-  static async ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#℘;
   }
-  static async ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‌_NJ;
   }
-  static async ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield * await this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+   return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
index 4955ed2681fa325a08ffb3ca8fe74d349c7ffa66..920a91064bd14e0f5d30c013558ca41e5dfab033 100644
--- a/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-wrapped-in-sc-rs-static-async-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 class C {
   ;;;;
   ;;;;;;static async * #$(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #_(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u{6F}(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #\u2118(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200C_NJ(value) {
-    yield await value;
+    yield * await value;
   }
   static async * #ZW_\u200D_J(value) {
-    yield await value;
+    yield * await value;
   };;;;;;;
   ;;;;
-  static async * $(value) {
-    yield * await this.#$(value);
+  static async * $() {
+    return this.#$;
   }
-  static async * _(value) {
-    yield * await this.#_(value);
+  static async * _() {
+    return this.#_;
   }
-  static async * \u{6F}(value) {
-    yield * await this.#\u{6F}(value);
+  static async * \u{6F}() {
+    return this.#\u{6F};
   }
-  static async * \u2118(value) {
-    yield * await this.#\u2118(value);
+  static async * \u2118() {
+    return this.#\u2118;
   }
-  static async * ZW_\u200C_NJ(value) {
-    yield * await this.#ZW_\u200C_NJ(value);
+  static async * ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static async * ZW_\u200D_J(value) {
-    yield * await this.#ZW_\u200D_J(value);
+  static async * ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
index 6f6590341d067a727b6ad0cb681661fffbb13b1e..2f6d85be72c05a97dacf544d1030e32514d5f9c2 100644
--- a/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier-alt.js
@@ -62,41 +62,41 @@ info: |
 class C {
   ;;;;
   ;;;;;;static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #o(value) {
-    yield value;
+    yield * value;
   }
   static * #℘(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‌_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_‍_J(value) {
-    yield value;
+    yield * value;
   };;;;;;;
   ;;;;
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * o(value) {
-    yield this.#o(value);
+  static get o() {
+    return this.#o;
   }
-  static * ℘(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#℘(value);
+  static get ℘() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#℘;
   }
-  static * ZW_‌_NJ(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‌_NJ(value);
+  static get ZW_‌_NJ() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‌_NJ;
   }
-  static * ZW_‍_J(value) { // DO NOT CHANGE THE NAME OF THIS FIELD
-    yield this.#ZW_‍_J(value);
+  static get ZW_‍_J() { // DO NOT CHANGE THE NAME OF THIS FIELD
+    return this.#ZW_‍_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
index 864a3b405bc3594ba21377e29214c84d52004c94..5bf360a9161addf296ae42666afed6fc30326115 100644
--- a/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/fields-wrapped-in-sc-rs-static-generator-method-privatename-identifier.js
@@ -62,41 +62,41 @@ info: |
 class C {
   ;;;;
   ;;;;;;static * #$(value) {
-    yield value;
+    yield * value;
   }
   static * #_(value) {
-    yield value;
+    yield * value;
   }
   static * #\u{6F}(value) {
-    yield value;
+    yield * value;
   }
   static * #\u2118(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200C_NJ(value) {
-    yield value;
+    yield * value;
   }
   static * #ZW_\u200D_J(value) {
-    yield value;
+    yield * value;
   };;;;;;;
   ;;;;
-  static * $(value) {
-    yield this.#$(value);
+  static get $() {
+    return this.#$;
   }
-  static * _(value) {
-    yield this.#_(value);
+  static get _() {
+    return this.#_;
   }
-  static * \u{6F}(value) {
-    yield this.#\u{6F}(value);
+  static get \u{6F}() {
+    return this.#\u{6F};
   }
-  static * \u2118(value) {
-    yield this.#\u2118(value);
+  static get \u2118() {
+    return this.#\u2118;
   }
-  static * ZW_\u200C_NJ(value) {
-    yield this.#ZW_\u200C_NJ(value);
+  static get ZW_\u200C_NJ() {
+    return this.#ZW_\u200C_NJ;
   }
-  static * ZW_\u200D_J(value) {
-    yield this.#ZW_\u200D_J(value);
+  static get ZW_\u200D_J() {
+    return this.#ZW_\u200D_J;
   }
 
 }
diff --git a/test/language/statements/class/fields-wrapped-in-sc-static-private-methods-with-fields.js b/test/language/statements/class/fields-wrapped-in-sc-static-private-methods-with-fields.js
new file mode 100644
index 0000000000000000000000000000000000000000..5ef217f215317db6e9cebad6af31ca069d8c1d8d
--- /dev/null
+++ b/test/language/statements/class/fields-wrapped-in-sc-static-private-methods-with-fields.js
@@ -0,0 +1,74 @@
+// This file was procedurally generated from the following sources:
+// - src/class-fields/static-private-methods-with-fields.case
+// - src/class-fields/productions/cls-decl-wrapped-in-sc.template
+/*---
+description: static private methods with fields (fields definition wrapped in semicolons)
+esid: prod-FieldDefinition
+features: [class-static-methods-private, class-static-fields-private, class, class-fields-public]
+flags: [generated]
+info: |
+    ClassElement :
+      ...
+      static FieldDefinition ;
+
+    FieldDefinition :
+      ClassElementName Initializer_opt
+
+    ClassElementName :
+      PrivateName
+
+    PrivateName :
+      # IdentifierName
+
+---*/
+
+
+class C {
+  ;;;;
+  ;;;;;;static #xVal; static #yVal;;;;;;;
+  ;;;;
+  static #x(value) {
+    this.#xVal = value;
+    return this.#xVal;
+  }
+  static #y(value) {
+    this.#yVal = value;
+    return this.#yVal;
+  }
+  static x() {
+    return this.#x(42);
+  }
+  static y() {
+    return this.#y(43);
+  }
+}
+
+var c = new C();
+
+// Test the private methods do not appear as properties before set to value
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
+assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
+assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+
+// Test if private fields can be sucessfully accessed and set to value
+assert.sameValue(C.x(), 42, "test 13");
+assert.sameValue(C.y(), 43, "test 14");
+
+// Test the private fields do not appear as properties before after set to value
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+
+assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
+assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
diff --git a/test/language/statements/class/fields-wrapped-in-sc-static-private-methods.js b/test/language/statements/class/fields-wrapped-in-sc-static-private-methods.js
index 1ad7a3ab0443c8d23f3f4bd68094f969c4348238..c547acb8dd5e2bd29e41f397b7928fca3647a57f 100644
--- a/test/language/statements/class/fields-wrapped-in-sc-static-private-methods.js
+++ b/test/language/statements/class/fields-wrapped-in-sc-static-private-methods.js
@@ -25,18 +25,16 @@ info: |
 
 class C {
   ;;;;
-  ;;;;;;static #xVal; static #yVal;;;;;;;
+  ;;;;;;;;;;;;;
   ;;;;
   static #x(value) {
-    this.#xVal = value;
-    return this.#xVal;
+    return value / 2;
   }
   static #y(value) {
-    this.#y = value;
-    return this.#yVal;
+    return value * 2;
   }
   static x() {
-    return this.#x(42);
+    return this.#x(84);
   }
   static y() {
     return this.#y(43);
@@ -46,18 +44,18 @@ class C {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 3");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
+assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 6");
+assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
+assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
-assert.sameValue(C.y(), 43, "test 8");
+assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 10");
+assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
+assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");