From 94a0eaeb8af9445a01b0a90e0f94303153210a86 Mon Sep 17 00:00:00 2001
From: Leo Balter <leonardo.balter@gmail.com>
Date: Fri, 16 Nov 2018 14:05:12 -0500
Subject: [PATCH] Generate tests
---
.../prod-private-async-generator.js | 142 ++++++++++++++++++
.../prod-private-async-method.js | 137 +++++++++++++++++
.../private-methods/prod-private-generator.js | 133 ++++++++++++++++
.../private-methods/prod-private-method.js | 128 ++++++++++++++++
.../prod-private-async-generator.js | 141 +++++++++++++++++
.../prod-private-async-method.js | 136 +++++++++++++++++
.../private-methods/prod-private-generator.js | 132 ++++++++++++++++
.../private-methods/prod-private-method.js | 128 ++++++++++++++++
8 files changed, 1077 insertions(+)
create mode 100644 test/language/expressions/class/private-methods/prod-private-async-generator.js
create mode 100644 test/language/expressions/class/private-methods/prod-private-async-method.js
create mode 100644 test/language/expressions/class/private-methods/prod-private-generator.js
create mode 100644 test/language/expressions/class/private-methods/prod-private-method.js
create mode 100644 test/language/statements/class/private-methods/prod-private-async-generator.js
create mode 100644 test/language/statements/class/private-methods/prod-private-async-method.js
create mode 100644 test/language/statements/class/private-methods/prod-private-generator.js
create mode 100644 test/language/statements/class/private-methods/prod-private-method.js
diff --git a/test/language/expressions/class/private-methods/prod-private-async-generator.js b/test/language/expressions/class/private-methods/prod-private-async-generator.js
new file mode 100644
index 0000000000..3c59cf207e
--- /dev/null
+++ b/test/language/expressions/class/private-methods/prod-private-async-generator.js
@@ -0,0 +1,142 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-async-generator.case
+// - src/class-elements/private-methods/cls-expr.template
+/*---
+description: Private Async Generator (private method definitions in a class expression)
+esid: prod-MethodDefinition
+features: [async-iteration]
+flags: [generated, async]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+var ctorPromise;
+
+
+
+/***
+ * template notes:
+ * 1. method should always be #m
+ * 2. the template provides c.ref/other.ref for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+var C = class {
+ async * #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ var ctorIter = this.#m();
+ var p = ctorIter.next();
+ ctorPromise = p.then(({ value, done }) => {
+ assert.sameValue(value, 42, 'return from generator method, inside ctor');
+ assert.sameValue(done, true, 'iterator is done, inside ctor');
+ }, $DONE);
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
+ctorPromise.then(() => {
+ var iter = c.ref();
+ return iter.next().then(({ value, done }) => {
+ assert.sameValue(value, 42, 'return from generator method');
+ assert.sameValue(done, true, 'iterator is done');
+ });
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/private-methods/prod-private-async-method.js b/test/language/expressions/class/private-methods/prod-private-async-method.js
new file mode 100644
index 0000000000..751c562834
--- /dev/null
+++ b/test/language/expressions/class/private-methods/prod-private-async-method.js
@@ -0,0 +1,137 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-async-method.case
+// - src/class-elements/private-methods/cls-expr.template
+/*---
+description: Private Async Method (private method definitions in a class expression)
+esid: prod-MethodDefinition
+features: [async-functions]
+flags: [generated, async]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+var ctorPromise;
+
+
+
+/***
+ * template notes:
+ * 1. method should always be #m
+ * 2. the template provides c.ref/other.ref for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+var C = class {
+ async #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+ ctorPromise = this.#m().then(value => {
+ assert.sameValue(this.#m(), 42, 'already defined in the ctor');
+ }, $DONE);
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
+ctorPromise.then(() => {
+ return c.ref().then(value => {
+ assert.sameValue(value, 42, 'function return');
+ });
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/private-methods/prod-private-generator.js b/test/language/expressions/class/private-methods/prod-private-generator.js
new file mode 100644
index 0000000000..c8f3458edd
--- /dev/null
+++ b/test/language/expressions/class/private-methods/prod-private-generator.js
@@ -0,0 +1,133 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-generator.case
+// - src/class-elements/private-methods/cls-expr.template
+/*---
+description: Private Generator (private method definitions in a class expression)
+esid: prod-MethodDefinition
+features: [generators]
+flags: [generated]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+
+
+/***
+ * template notes:
+ * 1. method should always be #m
+ * 2. the template provides c.ref/other.ref for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+var C = class {
+ * #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ var res = this.#m().next();
+ assert.sameValue(res.value, 42, 'return from generator method, inside ctor');
+ assert.sameValue(res.done, true, 'iterator is done, inside ctor');
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+var res = c.ref().next();
+assert.sameValue(res.value, 42, 'return from generator method');
+assert.sameValue(res.done, true, 'iterator is done');
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
diff --git a/test/language/expressions/class/private-methods/prod-private-method.js b/test/language/expressions/class/private-methods/prod-private-method.js
new file mode 100644
index 0000000000..06fec13c01
--- /dev/null
+++ b/test/language/expressions/class/private-methods/prod-private-method.js
@@ -0,0 +1,128 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-method.case
+// - src/class-elements/private-methods/cls-expr.template
+/*---
+description: Private Method (private method definitions in a class expression)
+esid: prod-MethodDefinition
+flags: [generated]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+
+
+/***
+ * template notes:
+ * 1. method should always be #m
+ * 2. the template provides c.ref/other.ref for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+var C = class {
+ #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ assert.sameValue(this.#m(), 42, 'already defined in the ctor');
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+assert.sameValue(c.ref(), 42, 'function return');
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
diff --git a/test/language/statements/class/private-methods/prod-private-async-generator.js b/test/language/statements/class/private-methods/prod-private-async-generator.js
new file mode 100644
index 0000000000..2b64fb6003
--- /dev/null
+++ b/test/language/statements/class/private-methods/prod-private-async-generator.js
@@ -0,0 +1,141 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-async-generator.case
+// - src/class-elements/private-methods/cls-decl.template
+/*---
+description: Private Async Generator (private method definitions in a class declaration)
+esid: prod-MethodDefinition
+features: [async-iteration, class, class-methods-private]
+flags: [generated, async]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+var ctorPromise;
+
+
+
+/*** template notes
+ * method should always be #m
+ * the template provides c.ref() for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+class C {
+ async * #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ var ctorIter = this.#m();
+ var p = ctorIter.next();
+ ctorPromise = p.then(({ value, done }) => {
+ assert.sameValue(value, 42, 'return from generator method, inside ctor');
+ assert.sameValue(done, true, 'iterator is done, inside ctor');
+ }, $DONE);
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
+ctorPromise.then(() => {
+ var iter = c.ref();
+ return iter.next().then(({ value, done }) => {
+ assert.sameValue(value, 42, 'return from generator method');
+ assert.sameValue(done, true, 'iterator is done');
+ });
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/private-methods/prod-private-async-method.js b/test/language/statements/class/private-methods/prod-private-async-method.js
new file mode 100644
index 0000000000..0ed2ea2e08
--- /dev/null
+++ b/test/language/statements/class/private-methods/prod-private-async-method.js
@@ -0,0 +1,136 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-async-method.case
+// - src/class-elements/private-methods/cls-decl.template
+/*---
+description: Private Async Method (private method definitions in a class declaration)
+esid: prod-MethodDefinition
+features: [async-functions, class, class-methods-private]
+flags: [generated, async]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+var ctorPromise;
+
+
+
+/*** template notes
+ * method should always be #m
+ * the template provides c.ref() for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+class C {
+ async #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+ ctorPromise = this.#m().then(value => {
+ assert.sameValue(this.#m(), 42, 'already defined in the ctor');
+ }, $DONE);
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
+ctorPromise.then(() => {
+ return c.ref().then(value => {
+ assert.sameValue(value, 42, 'function return');
+ });
+}, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/private-methods/prod-private-generator.js b/test/language/statements/class/private-methods/prod-private-generator.js
new file mode 100644
index 0000000000..c343e79bb7
--- /dev/null
+++ b/test/language/statements/class/private-methods/prod-private-generator.js
@@ -0,0 +1,132 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-generator.case
+// - src/class-elements/private-methods/cls-decl.template
+/*---
+description: Private Generator (private method definitions in a class declaration)
+esid: prod-MethodDefinition
+features: [generators, class, class-methods-private]
+flags: [generated]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+
+
+/*** template notes
+ * method should always be #m
+ * the template provides c.ref() for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+class C {
+ * #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ var res = this.#m().next();
+ assert.sameValue(res.value, 42, 'return from generator method, inside ctor');
+ assert.sameValue(res.done, true, 'iterator is done, inside ctor');
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+var res = c.ref().next();
+assert.sameValue(res.value, 42, 'return from generator method');
+assert.sameValue(res.done, true, 'iterator is done');
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
diff --git a/test/language/statements/class/private-methods/prod-private-method.js b/test/language/statements/class/private-methods/prod-private-method.js
new file mode 100644
index 0000000000..07d44da9c6
--- /dev/null
+++ b/test/language/statements/class/private-methods/prod-private-method.js
@@ -0,0 +1,128 @@
+// This file was procedurally generated from the following sources:
+// - src/class-elements/prod-private-method.case
+// - src/class-elements/private-methods/cls-decl.template
+/*---
+description: Private Method (private method definitions in a class declaration)
+esid: prod-MethodDefinition
+features: [class, class-methods-private]
+flags: [generated]
+info: |
+ ClassElement :
+ MethodDefinition
+ ...
+ ;
+
+ ClassElementName :
+ PropertyName
+ PrivateName
+
+ PrivateName ::
+ # IdentifierName
+
+ MethodDefinition :
+ ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ GeneratorMethod
+ AsyncMethod
+ AsyncGeneratorMethod
+ get ClassElementName () { FunctionBody }
+ set ClassElementName ( PropertySetParameterList ) { FunctionBody }
+
+ GeneratorMethod :
+ * ClassElementName ( UniqueFormalParameters ){GeneratorBody}
+
+ AsyncMethod :
+ async [no LineTerminator here] ClassElementName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+ AsyncGeneratorMethod :
+ async [no LineTerminator here]* ClassElementName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+ ---
+
+ InitializeClassElements ( F, proto )
+
+ ...
+ 5. For each item element in order from elements,
+ a. Assert: If element.[[Placement]] is "prototype" or "static", then element.[[Key]] is not a Private Name.
+ b. If element.[[Kind]] is "method" and element.[[Placement]] is "static" or "prototype",
+ i. Let receiver be F if element.[[Placement]] is "static", else let receiver be proto.
+ ii. Perform ? DefineClassElement(receiver, element).
+
+ InitializeInstanceElements ( O, constructor )
+
+ ...
+ 3. Let elements be the value of F's [[Elements]] internal slot.
+ 4. For each item element in order from elements,
+ a. If element.[[Placement]] is "own" and element.[[Kind]] is "method",
+ i. Perform ? DefineClassElement(O, element).
+
+ DefineClassElement (receiver, element)
+
+ ...
+ 6. If key is a Private Name,
+ a. Perform ? PrivateFieldDefine(receiver, key, descriptor).
+
+ PrivateFieldDefine (P, O, desc)
+
+ ...
+ 6. Append { [[PrivateName]]: P, [[PrivateFieldDescriptor]]: desc } to O.[[PrivateFieldDescriptors]].
+
+---*/
+
+
+/*** template notes
+ * method should always be #m
+ * the template provides c.ref() for external reference
+ */
+
+function hasOwnProperty(obj, name) {
+ return Object.prototype.hasOwnProperty.call(obj, name);
+}
+
+class C {
+ #m() { return 42; }
+
+
+ get ref() { return this.#m; }
+
+ constructor() {
+ assert.sameValue(
+ hasOwnProperty(this, '#m'), false,
+ 'private methods are defined in an special internal slot and cannot be found as own properties'
+ );
+ assert.sameValue(typeof this.#m, 'function');
+ assert.sameValue(this.ref(), this.#m, 'returns the same value');
+
+ assert.sameValue(this.#m(), 42, 'already defined in the ctor');
+ assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
+
+ }
+}
+
+var c = new C();
+var other = new C();
+
+assert.sameValue(
+ hasOwnProperty(C.prototype, '#m'), false,
+ 'method is not defined in the prototype'
+);
+
+assert.sameValue(
+ hasOwnProperty(C, '#m'), false,
+ 'method is not defined in the contructor'
+);
+
+assert.sameValue(
+ hasOwnProperty(c, '#m'), false,
+ 'method cannot be seen outside of the class'
+);
+
+/***
+ * MethodDefinition : ClassElementName ( UniqueFormalParameters ) { FunctionBody }
+ *
+ * 1. Let methodDef be DefineMethod of MethodDefinition with argument homeObject.
+ * ...
+ */
+assert.sameValue(c.ref, other.ref, 'The method is defined once, and reused on every new instance');
+
+assert.sameValue(c.ref(), 42, 'function return');
+assert.sameValue(c.ref.name, '#m', 'function name is preserved external reference');
--
GitLab