1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// |reftest| async
// 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 hasProp(obj, name, expected, msg) {
var hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, name);
assert.sameValue(hasOwnProperty, expected, msg);
var hasProperty = Reflect.has(obj, name);
assert.sameValue(hasProperty, expected, msg);
}
class C {
async #m() { return 42; }
get ref() { return this.#m; }
constructor() {
hasProp(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, (() => this)().#m, 'memberexpression and call expression forms');
assert.sameValue(this.#m.name, '#m', 'function name inside constructor');
ctorPromise = this.#m().then(value => {
assert.sameValue(value, 42, 'already defined in the ctor');
}, $DONE);
}
}
var c = new C();
var other = new C();
hasProp(C.prototype, '#m', false, 'method is not defined in the prototype');
hasProp(C, '#m', false, 'method is not defined in the contructor');
hasProp(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(() => {
// gets the returned promise from #m
return c.ref().then(value => {
assert.sameValue(value, 42, 'function return');
});
}).then($DONE, $DONE);
|