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
130
131
132
133
134
135
136
137
138
139
140
141
|
// This file was procedurally generated from the following sources:
// - src/class-elements/prod-private-method-initialize-order.case
// - src/class-elements/private-methods/cls-decl.template
/*---
description: Private methods are added before any field initializer is run, even if they appear textually later (private method definitions in a class declaration)
esid: prod-MethodDefinition
features: [class-methods-private, class-fields-private, class-fields-public, class]
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]].
InitializeInstanceElements ( O, constructor )
...
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).
5. For each item element in order from elements,
a. If element.[[Placement]] is "own" and element.[[Kind]] is "field",
i. Assert: element.[[Descriptor]] does not have a [[Value]], [[Get]] or [[Set]] slot.
ii. Perform ? DefineClassElement(O, element).
6. Return.
EDITOR'S NOTE:
Value properties are added before initializers so that private methods are visible from all initializers.
---*/
/*** 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 {
a = this.#m();
#m() { return 42; }
get bGetter() { return this.#b; }
#b = this.#m();
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.a, 42);
assert.sameValue(this.#b, 42);
}
}
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.a, 42);
assert.sameValue(c.bGetter, 42);
reportCompare(0, 0);
|
