Use JSC::EnsureStillAliveScope RAII object in the generated bindings code
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestGlobalObject.cpp
1 /*
2     This file is part of the WebKit open source project.
3     This file has been generated by generate-bindings.pl. DO NOT MODIFY!
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 of the License, or (at your option) any later version.
9
10     This library is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public License
16     along with this library; see the file COPYING.LIB.  If not, write to
17     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18     Boston, MA 02110-1301, USA.
19 */
20
21 #include "config.h"
22 #include "JSTestGlobalObject.h"
23
24 #include "ActiveDOMObject.h"
25 #include "DOMIsoSubspaces.h"
26 #include "DOMWrapperWorld.h"
27 #include "JSDOMAttribute.h"
28 #include "JSDOMBinding.h"
29 #include "JSDOMConstructorNotConstructable.h"
30 #include "JSDOMConvertBoolean.h"
31 #include "JSDOMConvertNumbers.h"
32 #include "JSDOMConvertStrings.h"
33 #include "JSDOMExceptionHandling.h"
34 #include "JSDOMOperation.h"
35 #include "JSDOMOperationReturningPromise.h"
36 #include "JSDOMWrapperCache.h"
37 #include "JSTestCEReactions.h"
38 #include "JSTestCEReactionsStringifier.h"
39 #include "JSTestCallTracer.h"
40 #include "JSTestClassWithJSBuiltinConstructor.h"
41 #include "JSTestDOMJIT.h"
42 #include "JSTestDomainSecurity.h"
43 #include "JSTestEnabledBySetting.h"
44 #include "JSTestEnabledForContext.h"
45 #include "JSTestEventConstructor.h"
46 #include "JSTestEventTarget.h"
47 #include "JSTestException.h"
48 #include "JSTestGenerateIsReachable.h"
49 #include "JSTestGlobalObject.h"
50 #include "JSTestIndexedSetterNoIdentifier.h"
51 #include "JSTestIndexedSetterThrowingException.h"
52 #include "JSTestIndexedSetterWithIdentifier.h"
53 #include "JSTestInterfaceLeadingUnderscore.h"
54 #include "JSTestIterable.h"
55 #include "JSTestJSBuiltinConstructor.h"
56 #include "JSTestMapLike.h"
57 #include "JSTestMediaQueryListListener.h"
58 #include "JSTestNamedAndIndexedSetterNoIdentifier.h"
59 #include "JSTestNamedAndIndexedSetterThrowingException.h"
60 #include "JSTestNamedAndIndexedSetterWithIdentifier.h"
61 #include "JSTestNamedConstructor.h"
62 #include "JSTestNamedConstructorNamed.h"
63 #include "JSTestNamedDeleterNoIdentifier.h"
64 #include "JSTestNamedDeleterThrowingException.h"
65 #include "JSTestNamedDeleterWithIdentifier.h"
66 #include "JSTestNamedDeleterWithIndexedGetter.h"
67 #include "JSTestNamedGetterCallWith.h"
68 #include "JSTestNamedGetterNoIdentifier.h"
69 #include "JSTestNamedGetterWithIdentifier.h"
70 #include "JSTestNamedSetterNoIdentifier.h"
71 #include "JSTestNamedSetterThrowingException.h"
72 #include "JSTestNamedSetterWithIdentifier.h"
73 #include "JSTestNamedSetterWithIndexedGetter.h"
74 #include "JSTestNamedSetterWithIndexedGetterAndSetter.h"
75 #include "JSTestNamedSetterWithOverrideBuiltins.h"
76 #include "JSTestNamedSetterWithUnforgableProperties.h"
77 #include "JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.h"
78 #include "JSTestOverloadedConstructors.h"
79 #include "JSTestOverloadedConstructorsWithSequence.h"
80 #include "JSTestOverrideBuiltins.h"
81 #include "JSTestPluginInterface.h"
82 #include "JSTestReadOnlyMapLike.h"
83 #include "JSTestReadOnlySetLike.h"
84 #include "JSTestReportExtraMemoryCost.h"
85 #include "JSTestSerialization.h"
86 #include "JSTestSerializationIndirectInheritance.h"
87 #include "JSTestSerializationInherit.h"
88 #include "JSTestSerializationInheritFinal.h"
89 #include "JSTestSetLike.h"
90 #include "JSTestStringifier.h"
91 #include "JSTestStringifierAnonymousOperation.h"
92 #include "JSTestStringifierNamedOperation.h"
93 #include "JSTestStringifierOperationImplementedAs.h"
94 #include "JSTestStringifierOperationNamedToString.h"
95 #include "JSTestStringifierReadOnlyAttribute.h"
96 #include "JSTestStringifierReadWriteAttribute.h"
97 #include "JSTestTypedefs.h"
98 #include "RuntimeEnabledFeatures.h"
99 #include "ScriptExecutionContext.h"
100 #include "WebCoreJSClientData.h"
101 #include <JavaScriptCore/FunctionPrototype.h>
102 #include <JavaScriptCore/HeapAnalyzer.h>
103 #include <JavaScriptCore/JSCInlines.h>
104 #include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
105 #include <JavaScriptCore/SubspaceInlines.h>
106 #include <wtf/GetPtr.h>
107 #include <wtf/PointerPreparations.h>
108 #include <wtf/URL.h>
109
110 #if ENABLE(Condition1) || ENABLE(Condition2)
111 #include "JSTestInterface.h"
112 #include "JSTestSerializedScriptValueInterface.h"
113 #endif
114
115 #if ENABLE(TEST_CONDITIONAL)
116 #include "JSTestCallbackInterface.h"
117 #endif
118
119 #if ENABLE(TEST_FEATURE)
120 #include "TestGlobalObjectBuiltins.h"
121 #endif
122
123
124 namespace WebCore {
125 using namespace JSC;
126
127 // Functions
128
129 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionRegularOperation(JSC::JSGlobalObject*, JSC::CallFrame*);
130 #if ENABLE(TEST_FEATURE)
131 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation(JSC::JSGlobalObject*, JSC::CallFrame*);
132 #endif
133 #if ENABLE(TEST_FEATURE)
134 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectConstructorFunctionEnabledAtRuntimeOperationStatic(JSC::JSGlobalObject*, JSC::CallFrame*);
135 #endif
136 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorld(JSC::JSGlobalObject*, JSC::CallFrame*);
137 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeatureEnabled(JSC::JSGlobalObject*, JSC::CallFrame*);
138 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeaturesEnabled(JSC::JSGlobalObject*, JSC::CallFrame*);
139 #if ENABLE(TEST_FEATURE)
140 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionTestPrivateFunction(JSC::JSGlobalObject*, JSC::CallFrame*);
141 #endif
142 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionCalculateSecretResult(JSC::JSGlobalObject*, JSC::CallFrame*);
143 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionGetSecretBoolean(JSC::JSGlobalObject*, JSC::CallFrame*);
144 #if ENABLE(TEST_FEATURE)
145 JSC::EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionTestFeatureGetSecretBoolean(JSC::JSGlobalObject*, JSC::CallFrame*);
146 #endif
147
148 // Attributes
149
150 JSC::EncodedJSValue jsTestGlobalObjectConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
151 bool setJSTestGlobalObjectConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
152 JSC::EncodedJSValue jsTestGlobalObjectRegularAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
153 bool setJSTestGlobalObjectRegularAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
154 JSC::EncodedJSValue jsTestGlobalObjectPublicAndPrivateAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
155 bool setJSTestGlobalObjectPublicAndPrivateAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
156 #if ENABLE(TEST_FEATURE)
157 JSC::EncodedJSValue jsTestGlobalObjectPublicAndPrivateConditionalAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
158 bool setJSTestGlobalObjectPublicAndPrivateConditionalAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
159 #endif
160 #if ENABLE(TEST_FEATURE)
161 JSC::EncodedJSValue jsTestGlobalObjectEnabledAtRuntimeAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
162 bool setJSTestGlobalObjectEnabledAtRuntimeAttribute(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
163 #endif
164 JSC::EncodedJSValue jsTestGlobalObjectTestCEReactionsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
165 bool setJSTestGlobalObjectTestCEReactionsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
166 JSC::EncodedJSValue jsTestGlobalObjectTestCEReactionsStringifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
167 bool setJSTestGlobalObjectTestCEReactionsStringifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
168 JSC::EncodedJSValue jsTestGlobalObjectTestCallTracerConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
169 bool setJSTestGlobalObjectTestCallTracerConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
170 #if ENABLE(TEST_CONDITIONAL)
171 JSC::EncodedJSValue jsTestGlobalObjectTestCallbackInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
172 bool setJSTestGlobalObjectTestCallbackInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
173 #endif
174 JSC::EncodedJSValue jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
175 bool setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
176 JSC::EncodedJSValue jsTestGlobalObjectTestDOMJITConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
177 bool setJSTestGlobalObjectTestDOMJITConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
178 JSC::EncodedJSValue jsTestGlobalObjectTestDomainSecurityConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
179 bool setJSTestGlobalObjectTestDomainSecurityConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
180 JSC::EncodedJSValue jsTestGlobalObjectTestEnabledBySettingConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
181 bool setJSTestGlobalObjectTestEnabledBySettingConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
182 JSC::EncodedJSValue jsTestGlobalObjectTestEnabledForContextConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
183 bool setJSTestGlobalObjectTestEnabledForContextConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
184 JSC::EncodedJSValue jsTestGlobalObjectTestEventConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
185 bool setJSTestGlobalObjectTestEventConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
186 JSC::EncodedJSValue jsTestGlobalObjectTestEventTargetConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
187 bool setJSTestGlobalObjectTestEventTargetConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
188 JSC::EncodedJSValue jsTestGlobalObjectTestExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
189 bool setJSTestGlobalObjectTestExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
190 JSC::EncodedJSValue jsTestGlobalObjectTestGenerateIsReachableConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
191 bool setJSTestGlobalObjectTestGenerateIsReachableConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
192 JSC::EncodedJSValue jsTestGlobalObjectTestGlobalObjectConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
193 bool setJSTestGlobalObjectTestGlobalObjectConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
194 JSC::EncodedJSValue jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
195 bool setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
196 JSC::EncodedJSValue jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
197 bool setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
198 JSC::EncodedJSValue jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
199 bool setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
200 #if ENABLE(Condition1) || ENABLE(Condition2)
201 JSC::EncodedJSValue jsTestGlobalObjectTestInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
202 bool setJSTestGlobalObjectTestInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
203 #endif
204 JSC::EncodedJSValue jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
205 bool setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
206 JSC::EncodedJSValue jsTestGlobalObjectTestIterableConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
207 bool setJSTestGlobalObjectTestIterableConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
208 JSC::EncodedJSValue jsTestGlobalObjectTestJSBuiltinConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
209 bool setJSTestGlobalObjectTestJSBuiltinConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
210 JSC::EncodedJSValue jsTestGlobalObjectTestMapLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
211 bool setJSTestGlobalObjectTestMapLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
212 JSC::EncodedJSValue jsTestGlobalObjectTestMediaQueryListListenerConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
213 bool setJSTestGlobalObjectTestMediaQueryListListenerConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
214 JSC::EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
215 bool setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
216 JSC::EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
217 bool setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
218 JSC::EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
219 bool setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
220 JSC::EncodedJSValue jsTestGlobalObjectTestNamedConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
221 bool setJSTestGlobalObjectTestNamedConstructorConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
222 JSC::EncodedJSValue jsTestGlobalObjectAudioConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
223 bool setJSTestGlobalObjectAudioConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
224 JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
225 bool setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
226 JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
227 bool setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
228 JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
229 bool setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
230 JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
231 bool setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
232 JSC::EncodedJSValue jsTestGlobalObjectTestNamedGetterCallWithConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
233 bool setJSTestGlobalObjectTestNamedGetterCallWithConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
234 JSC::EncodedJSValue jsTestGlobalObjectTestNamedGetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
235 bool setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
236 JSC::EncodedJSValue jsTestGlobalObjectTestNamedGetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
237 bool setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
238 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
239 bool setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
240 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
241 bool setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
242 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
243 bool setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
244 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
245 bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
246 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
247 bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
248 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
249 bool setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
250 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
251 bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
252 JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
253 bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
254 JSC::EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
255 bool setJSTestGlobalObjectTestOverloadedConstructorsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
256 JSC::EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
257 bool setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
258 JSC::EncodedJSValue jsTestGlobalObjectTestOverrideBuiltinsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
259 bool setJSTestGlobalObjectTestOverrideBuiltinsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
260 JSC::EncodedJSValue jsTestGlobalObjectTestPluginInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
261 bool setJSTestGlobalObjectTestPluginInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
262 JSC::EncodedJSValue jsTestGlobalObjectTestReadOnlyMapLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
263 bool setJSTestGlobalObjectTestReadOnlyMapLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
264 JSC::EncodedJSValue jsTestGlobalObjectTestReadOnlySetLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
265 bool setJSTestGlobalObjectTestReadOnlySetLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
266 JSC::EncodedJSValue jsTestGlobalObjectTestReportExtraMemoryCostConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
267 bool setJSTestGlobalObjectTestReportExtraMemoryCostConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
268 JSC::EncodedJSValue jsTestGlobalObjectTestSerializationConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
269 bool setJSTestGlobalObjectTestSerializationConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
270 JSC::EncodedJSValue jsTestGlobalObjectTestSerializationIndirectInheritanceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
271 bool setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
272 JSC::EncodedJSValue jsTestGlobalObjectTestSerializationInheritConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
273 bool setJSTestGlobalObjectTestSerializationInheritConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
274 JSC::EncodedJSValue jsTestGlobalObjectTestSerializationInheritFinalConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
275 bool setJSTestGlobalObjectTestSerializationInheritFinalConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
276 #if ENABLE(Condition1) || ENABLE(Condition2)
277 JSC::EncodedJSValue jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
278 bool setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
279 #endif
280 JSC::EncodedJSValue jsTestGlobalObjectTestSetLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
281 bool setJSTestGlobalObjectTestSetLikeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
282 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
283 bool setJSTestGlobalObjectTestStringifierConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
284 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierAnonymousOperationConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
285 bool setJSTestGlobalObjectTestStringifierAnonymousOperationConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
286 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierNamedOperationConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
287 bool setJSTestGlobalObjectTestStringifierNamedOperationConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
288 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierOperationImplementedAsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
289 bool setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
290 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierOperationNamedToStringConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
291 bool setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
292 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
293 bool setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
294 JSC::EncodedJSValue jsTestGlobalObjectTestStringifierReadWriteAttributeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
295 bool setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
296 JSC::EncodedJSValue jsTestGlobalObjectTestTypedefsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::PropertyName);
297 bool setJSTestGlobalObjectTestTypedefsConstructor(JSC::JSGlobalObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
298
299 using JSTestGlobalObjectConstructor = JSDOMConstructorNotConstructable<JSTestGlobalObject>;
300
301 /* Hash table */
302
303 static const struct CompactHashIndex JSTestGlobalObjectTableIndex[266] = {
304     { -1, -1 },
305     { 37, -1 },
306     { -1, -1 },
307     { 0, -1 },
308     { 4, 262 },
309     { 41, -1 },
310     { -1, -1 },
311     { -1, -1 },
312     { -1, -1 },
313     { -1, -1 },
314     { -1, -1 },
315     { -1, -1 },
316     { -1, -1 },
317     { 51, -1 },
318     { -1, -1 },
319     { -1, -1 },
320     { -1, -1 },
321     { 19, -1 },
322     { -1, -1 },
323     { -1, -1 },
324     { -1, -1 },
325     { 63, -1 },
326     { -1, -1 },
327     { -1, -1 },
328     { -1, -1 },
329     { -1, -1 },
330     { -1, -1 },
331     { -1, -1 },
332     { -1, -1 },
333     { -1, -1 },
334     { -1, -1 },
335     { -1, -1 },
336     { -1, -1 },
337     { -1, -1 },
338     { -1, -1 },
339     { 31, -1 },
340     { -1, -1 },
341     { -1, -1 },
342     { -1, -1 },
343     { -1, -1 },
344     { -1, -1 },
345     { 66, -1 },
346     { 9, 258 },
347     { -1, -1 },
348     { -1, -1 },
349     { -1, -1 },
350     { -1, -1 },
351     { -1, -1 },
352     { -1, -1 },
353     { -1, -1 },
354     { 35, -1 },
355     { 16, 263 },
356     { 6, -1 },
357     { -1, -1 },
358     { -1, -1 },
359     { -1, -1 },
360     { -1, -1 },
361     { -1, -1 },
362     { -1, -1 },
363     { -1, -1 },
364     { -1, -1 },
365     { -1, -1 },
366     { -1, -1 },
367     { 33, -1 },
368     { -1, -1 },
369     { -1, -1 },
370     { -1, -1 },
371     { -1, -1 },
372     { -1, -1 },
373     { -1, -1 },
374     { 18, 264 },
375     { -1, -1 },
376     { -1, -1 },
377     { -1, -1 },
378     { -1, -1 },
379     { -1, -1 },
380     { 5, -1 },
381     { -1, -1 },
382     { -1, -1 },
383     { -1, -1 },
384     { -1, -1 },
385     { -1, -1 },
386     { -1, -1 },
387     { -1, -1 },
388     { -1, -1 },
389     { 57, -1 },
390     { -1, -1 },
391     { -1, -1 },
392     { -1, -1 },
393     { -1, -1 },
394     { -1, -1 },
395     { -1, -1 },
396     { 20, 256 },
397     { -1, -1 },
398     { 58, -1 },
399     { 15, -1 },
400     { -1, -1 },
401     { -1, -1 },
402     { 43, -1 },
403     { 14, -1 },
404     { -1, -1 },
405     { -1, -1 },
406     { -1, -1 },
407     { -1, -1 },
408     { 32, -1 },
409     { -1, -1 },
410     { -1, -1 },
411     { -1, -1 },
412     { -1, -1 },
413     { -1, -1 },
414     { -1, -1 },
415     { 47, -1 },
416     { 21, -1 },
417     { -1, -1 },
418     { 2, -1 },
419     { 34, -1 },
420     { -1, -1 },
421     { -1, -1 },
422     { -1, -1 },
423     { 17, -1 },
424     { -1, -1 },
425     { -1, -1 },
426     { -1, -1 },
427     { -1, -1 },
428     { -1, -1 },
429     { 55, -1 },
430     { -1, -1 },
431     { -1, -1 },
432     { -1, -1 },
433     { -1, -1 },
434     { -1, -1 },
435     { 28, -1 },
436     { 24, -1 },
437     { -1, -1 },
438     { 39, -1 },
439     { -1, -1 },
440     { -1, -1 },
441     { -1, -1 },
442     { -1, -1 },
443     { -1, -1 },
444     { 50, -1 },
445     { -1, -1 },
446     { 10, -1 },
447     { -1, -1 },
448     { -1, -1 },
449     { -1, -1 },
450     { -1, -1 },
451     { -1, -1 },
452     { -1, -1 },
453     { -1, -1 },
454     { -1, -1 },
455     { -1, -1 },
456     { -1, -1 },
457     { -1, -1 },
458     { -1, -1 },
459     { -1, -1 },
460     { -1, -1 },
461     { -1, -1 },
462     { 64, -1 },
463     { -1, -1 },
464     { -1, -1 },
465     { -1, -1 },
466     { 29, -1 },
467     { 26, 261 },
468     { -1, -1 },
469     { -1, -1 },
470     { -1, -1 },
471     { -1, -1 },
472     { -1, -1 },
473     { -1, -1 },
474     { -1, -1 },
475     { -1, -1 },
476     { -1, -1 },
477     { 12, 257 },
478     { -1, -1 },
479     { 59, -1 },
480     { -1, -1 },
481     { -1, -1 },
482     { -1, -1 },
483     { -1, -1 },
484     { -1, -1 },
485     { -1, -1 },
486     { -1, -1 },
487     { -1, -1 },
488     { 30, 265 },
489     { -1, -1 },
490     { 13, -1 },
491     { -1, -1 },
492     { 62, -1 },
493     { -1, -1 },
494     { -1, -1 },
495     { -1, -1 },
496     { -1, -1 },
497     { -1, -1 },
498     { 45, -1 },
499     { -1, -1 },
500     { -1, -1 },
501     { -1, -1 },
502     { -1, -1 },
503     { -1, -1 },
504     { -1, -1 },
505     { -1, -1 },
506     { -1, -1 },
507     { -1, -1 },
508     { -1, -1 },
509     { -1, -1 },
510     { -1, -1 },
511     { 53, -1 },
512     { -1, -1 },
513     { -1, -1 },
514     { -1, -1 },
515     { -1, -1 },
516     { -1, -1 },
517     { -1, -1 },
518     { -1, -1 },
519     { -1, -1 },
520     { -1, -1 },
521     { -1, -1 },
522     { -1, -1 },
523     { -1, -1 },
524     { -1, -1 },
525     { -1, -1 },
526     { 1, -1 },
527     { -1, -1 },
528     { 8, -1 },
529     { -1, -1 },
530     { -1, -1 },
531     { -1, -1 },
532     { -1, -1 },
533     { 46, -1 },
534     { 7, 260 },
535     { -1, -1 },
536     { 60, -1 },
537     { -1, -1 },
538     { 44, -1 },
539     { -1, -1 },
540     { -1, -1 },
541     { -1, -1 },
542     { -1, -1 },
543     { 11, -1 },
544     { -1, -1 },
545     { 22, -1 },
546     { -1, -1 },
547     { -1, -1 },
548     { 25, -1 },
549     { -1, -1 },
550     { -1, -1 },
551     { 42, -1 },
552     { 3, -1 },
553     { 48, -1 },
554     { -1, -1 },
555     { 49, -1 },
556     { -1, -1 },
557     { -1, -1 },
558     { -1, -1 },
559     { -1, -1 },
560     { 23, 259 },
561     { 27, -1 },
562     { 36, -1 },
563     { 38, -1 },
564     { 40, -1 },
565     { 52, -1 },
566     { 54, -1 },
567     { 56, -1 },
568     { 61, -1 },
569     { 65, -1 },
570 };
571
572
573 static const HashTableValue JSTestGlobalObjectTableValues[] =
574 {
575     { "regularAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectRegularAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectRegularAttribute) } },
576     { "publicAndPrivateAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectPublicAndPrivateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectPublicAndPrivateAttribute) } },
577 #if ENABLE(TEST_FEATURE)
578     { "publicAndPrivateConditionalAttribute", static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectPublicAndPrivateConditionalAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectPublicAndPrivateConditionalAttribute) } },
579 #else
580     { 0, 0, NoIntrinsic, { 0, 0 } },
581 #endif
582     { "TestCEReactions", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCEReactionsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCEReactionsConstructor) } },
583     { "TestCEReactionsStringifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCEReactionsStringifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCEReactionsStringifierConstructor) } },
584     { "TestCallTracer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCallTracerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCallTracerConstructor) } },
585 #if ENABLE(TEST_CONDITIONAL)
586     { "TestCallbackInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCallbackInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCallbackInterfaceConstructor) } },
587 #else
588     { 0, 0, NoIntrinsic, { 0, 0 } },
589 #endif
590     { "TestClassWithJSBuiltinConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor) } },
591     { "TestDOMJIT", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestDOMJITConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestDOMJITConstructor) } },
592     { "TestDomainSecurity", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestDomainSecurityConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestDomainSecurityConstructor) } },
593     { "TestEnabledBySetting", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestEnabledBySettingConstructor) } },
594     { "TestEventConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestEventConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestEventConstructorConstructor) } },
595     { "TestEventTarget", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestEventTargetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestEventTargetConstructor) } },
596     { "TestException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestExceptionConstructor) } },
597     { "TestGenerateIsReachable", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestGenerateIsReachableConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestGenerateIsReachableConstructor) } },
598     { "TestGlobalObject", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestGlobalObjectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestGlobalObjectConstructor) } },
599     { "TestIndexedSetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructor) } },
600     { "TestIndexedSetterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor) } },
601     { "TestIndexedSetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructor) } },
602 #if ENABLE(Condition1) || ENABLE(Condition2)
603     { "TestInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestInterfaceConstructor) } },
604 #else
605     { 0, 0, NoIntrinsic, { 0, 0 } },
606 #endif
607     { "TestInterfaceLeadingUnderscore", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor) } },
608     { "TestIterable", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIterableConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIterableConstructor) } },
609     { "TestJSBuiltinConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestJSBuiltinConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestJSBuiltinConstructorConstructor) } },
610     { "TestMapLike", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestMapLikeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestMapLikeConstructor) } },
611     { "TestMediaQueryListListener", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestMediaQueryListListenerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestMediaQueryListListenerConstructor) } },
612     { "TestNamedAndIndexedSetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor) } },
613     { "TestNamedAndIndexedSetterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor) } },
614     { "TestNamedAndIndexedSetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor) } },
615     { "TestNamedConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedConstructorConstructor) } },
616     { "Audio", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectAudioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectAudioConstructor) } },
617     { "TestNamedDeleterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructor) } },
618     { "TestNamedDeleterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor) } },
619     { "TestNamedDeleterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructor) } },
620     { "TestNamedDeleterWithIndexedGetter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor) } },
621     { "TestNamedGetterCallWith", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedGetterCallWithConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedGetterCallWithConstructor) } },
622     { "TestNamedGetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedGetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructor) } },
623     { "TestNamedGetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedGetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructor) } },
624     { "TestNamedSetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructor) } },
625     { "TestNamedSetterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructor) } },
626     { "TestNamedSetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructor) } },
627     { "TestNamedSetterWithIndexedGetter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor) } },
628     { "TestNamedSetterWithIndexedGetterAndSetter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor) } },
629     { "TestNamedSetterWithOverrideBuiltins", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor) } },
630     { "TestNamedSetterWithUnforgableProperties", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor) } },
631     { "TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor) } },
632     { "TestOverloadedConstructors", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestOverloadedConstructorsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestOverloadedConstructorsConstructor) } },
633     { "TestOverloadedConstructorsWithSequence", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor) } },
634     { "TestOverrideBuiltins", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestOverrideBuiltinsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestOverrideBuiltinsConstructor) } },
635     { "TestPluginInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestPluginInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestPluginInterfaceConstructor) } },
636     { "TestReadOnlyMapLike", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestReadOnlyMapLikeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestReadOnlyMapLikeConstructor) } },
637     { "TestReadOnlySetLike", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestReadOnlySetLikeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestReadOnlySetLikeConstructor) } },
638     { "TestReportExtraMemoryCost", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestReportExtraMemoryCostConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestReportExtraMemoryCostConstructor) } },
639     { "TestSerialization", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationConstructor) } },
640     { "TestSerializationIndirectInheritance", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationIndirectInheritanceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructor) } },
641     { "TestSerializationInherit", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationInheritConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationInheritConstructor) } },
642     { "TestSerializationInheritFinal", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationInheritFinalConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationInheritFinalConstructor) } },
643 #if ENABLE(Condition1) || ENABLE(Condition2)
644     { "TestSerializedScriptValueInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructor) } },
645 #else
646     { 0, 0, NoIntrinsic, { 0, 0 } },
647 #endif
648     { "TestSetLike", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSetLikeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSetLikeConstructor) } },
649     { "TestStringifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierConstructor) } },
650     { "TestStringifierAnonymousOperation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierAnonymousOperationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierAnonymousOperationConstructor) } },
651     { "TestStringifierNamedOperation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierNamedOperationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierNamedOperationConstructor) } },
652     { "TestStringifierOperationImplementedAs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierOperationImplementedAsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructor) } },
653     { "TestStringifierOperationNamedToString", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierOperationNamedToStringConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructor) } },
654     { "TestStringifierReadOnlyAttribute", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructor) } },
655     { "TestStringifierReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierReadWriteAttributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructor) } },
656     { "TestTypedefs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestTypedefsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestTypedefsConstructor) } },
657     { "regularOperation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestGlobalObjectInstanceFunctionRegularOperation), (intptr_t) (1) } },
658 };
659
660 static const HashTable JSTestGlobalObjectTable = { 67, 255, true, JSTestGlobalObject::info(), JSTestGlobalObjectTableValues, JSTestGlobalObjectTableIndex };
661 /* Hash table for constructor */
662
663 static const HashTableValue JSTestGlobalObjectConstructorTableValues[] =
664 {
665 #if ENABLE(TEST_FEATURE)
666     { "enabledAtRuntimeOperationStatic", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestGlobalObjectConstructorFunctionEnabledAtRuntimeOperationStatic), (intptr_t) (1) } },
667 #else
668     { 0, 0, NoIntrinsic, { 0, 0 } },
669 #endif
670 };
671
672 template<> JSValue JSTestGlobalObjectConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
673 {
674     UNUSED_PARAM(vm);
675     return globalObject.functionPrototype();
676 }
677
678 template<> void JSTestGlobalObjectConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
679 {
680     putDirect(vm, vm.propertyNames->prototype, globalObject.getPrototypeDirect(vm), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
681     putDirect(vm, vm.propertyNames->name, jsNontrivialString(vm, String("TestGlobalObject"_s)), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
682     putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
683     reifyStaticProperties(vm, JSTestGlobalObject::info(), JSTestGlobalObjectConstructorTableValues, *this);
684 }
685
686 template<> const ClassInfo JSTestGlobalObjectConstructor::s_info = { "TestGlobalObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestGlobalObjectConstructor) };
687
688 /* Hash table for prototype */
689
690 static const struct CompactHashIndex JSTestGlobalObjectPrototypeTableIndex[2] = {
691     { -1, -1 },
692     { 0, -1 },
693 };
694
695
696 static const HashTableValue JSTestGlobalObjectPrototypeTableValues[] =
697 {
698     { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectConstructor) } },
699 };
700
701 static const HashTable JSTestGlobalObjectPrototypeTable = { 1, 1, true, JSTestGlobalObject::info(), JSTestGlobalObjectPrototypeTableValues, JSTestGlobalObjectPrototypeTableIndex };
702 const ClassInfo JSTestGlobalObjectPrototype::s_info = { "TestGlobalObjectPrototype", &Base::s_info, &JSTestGlobalObjectPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSTestGlobalObjectPrototype) };
703
704 const ClassInfo JSTestGlobalObject::s_info = { "TestGlobalObject", &Base::s_info, &JSTestGlobalObjectTable, nullptr, CREATE_METHOD_TABLE(JSTestGlobalObject) };
705
706 JSTestGlobalObject::JSTestGlobalObject(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestGlobalObject>&& impl)
707     : JSDOMWrapper<TestGlobalObject>(structure, globalObject, WTFMove(impl))
708 {
709 }
710
711 void JSTestGlobalObject::finishCreation(VM& vm)
712 {
713     Base::finishCreation(vm);
714     ASSERT(inherits(vm, info()));
715
716     static_assert(!std::is_base_of<ActiveDOMObject, TestGlobalObject>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
717
718 #if ENABLE(TEST_FEATURE)
719     if (RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
720         putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().enabledAtRuntimeAttributePublicName(), CustomGetterSetter::create(vm, jsTestGlobalObjectEnabledAtRuntimeAttribute, setJSTestGlobalObjectEnabledAtRuntimeAttribute), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor)));
721 #endif
722     if ((jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext()->isSecureContext() && TestEnabledForContext::enabledForContext(*jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext())))
723         putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().TestEnabledForContextPublicName(), CustomGetterSetter::create(vm, jsTestGlobalObjectTestEnabledForContextConstructor, setJSTestGlobalObjectTestEnabledForContextConstructor), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::DontEnum)));
724     putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().publicAndPrivateAttributePrivateName(), CustomGetterSetter::create(vm, jsTestGlobalObjectPublicAndPrivateAttribute, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
725 #if ENABLE(TEST_FEATURE)
726     putDirectCustomAccessor(vm, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().publicAndPrivateConditionalAttributePrivateName(), CustomGetterSetter::create(vm, jsTestGlobalObjectPublicAndPrivateConditionalAttribute, nullptr), attributesForStructure(JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly));
727 #endif
728 #if ENABLE(TEST_FEATURE)
729     if (RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
730         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().enabledAtRuntimeOperationPublicName(), 1, jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
731 #endif
732 #if ENABLE(TEST_FEATURE)
733     if (RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
734         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().enabledAtRuntimeOperationStaticPublicName(), 1, jsTestGlobalObjectConstructorFunctionEnabledAtRuntimeOperationStatic, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
735 #endif
736     if (worldForDOMObject(*this).specificWorld())
737         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().enabledInSpecificWorldPublicName(), 1, jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorld, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
738     if ((worldForDOMObject(*this).specificWorld() && RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()))
739         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().enabledInSpecificWorldWhenRuntimeFeatureEnabledPublicName(), 1, jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeatureEnabled, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
740     if ((worldForDOMObject(*this).specificWorld() && RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled() && RuntimeEnabledFeatures::sharedFeatures().testFeature1Enabled()))
741         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().enabledInSpecificWorldWhenRuntimeFeaturesEnabledPublicName(), 1, jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeaturesEnabled, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
742 #if ENABLE(TEST_FEATURE)
743     if (RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
744         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().testPrivateFunctionPrivateName(), 0, jsTestGlobalObjectInstanceFunctionTestPrivateFunction, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
745 #endif
746 #if ENABLE(TEST_FEATURE)
747     if (RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled())
748         putDirectBuiltinFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().testJSBuiltinFunctionPublicName(), testGlobalObjectTestJSBuiltinFunctionCodeGenerator(vm), attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Builtin)));
749 #endif
750     if (jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext()->isSecureContext())
751         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().calculateSecretResultPublicName(), 0, jsTestGlobalObjectInstanceFunctionCalculateSecretResult, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
752     if (jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext()->isSecureContext())
753         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().getSecretBooleanPublicName(), 0, jsTestGlobalObjectInstanceFunctionGetSecretBoolean, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
754 #if ENABLE(TEST_FEATURE)
755     if ((jsCast<JSDOMGlobalObject*>(globalObject())->scriptExecutionContext()->isSecureContext() && RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()))
756         putDirectNativeFunction(vm, this, static_cast<JSVMClientData*>(vm.clientData)->builtinNames().testFeatureGetSecretBooleanPublicName(), 0, jsTestGlobalObjectInstanceFunctionTestFeatureGetSecretBoolean, NoIntrinsic, attributesForStructure(static_cast<unsigned>(JSC::PropertyAttribute::Function)));
757 #endif
758 }
759
760 JSValue JSTestGlobalObject::getConstructor(VM& vm, const JSGlobalObject* globalObject)
761 {
762     return getDOMConstructor<JSTestGlobalObjectConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
763 }
764
765 void JSTestGlobalObject::destroy(JSC::JSCell* cell)
766 {
767     JSTestGlobalObject* thisObject = static_cast<JSTestGlobalObject*>(cell);
768     thisObject->JSTestGlobalObject::~JSTestGlobalObject();
769 }
770
771 template<> inline JSTestGlobalObject* IDLAttribute<JSTestGlobalObject>::cast(JSGlobalObject& lexicalGlobalObject, EncodedJSValue thisValue)
772 {
773     return jsDynamicCast<JSTestGlobalObject*>(JSC::getVM(&lexicalGlobalObject), JSValue::decode(thisValue));
774 }
775
776 template<> inline JSTestGlobalObject* IDLOperation<JSTestGlobalObject>::cast(JSGlobalObject& lexicalGlobalObject, CallFrame& callFrame)
777 {
778     return jsDynamicCast<JSTestGlobalObject*>(JSC::getVM(&lexicalGlobalObject), callFrame.thisValue());
779 }
780
781 EncodedJSValue jsTestGlobalObjectConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
782 {
783     VM& vm = JSC::getVM(lexicalGlobalObject);
784     auto throwScope = DECLARE_THROW_SCOPE(vm);
785     auto* prototype = jsDynamicCast<JSTestGlobalObjectPrototype*>(vm, JSValue::decode(thisValue));
786     if (UNLIKELY(!prototype))
787         return throwVMTypeError(lexicalGlobalObject, throwScope);
788     return JSValue::encode(JSTestGlobalObject::getConstructor(JSC::getVM(lexicalGlobalObject), prototype->globalObject()));
789 }
790
791 bool setJSTestGlobalObjectConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
792 {
793     VM& vm = JSC::getVM(lexicalGlobalObject);
794     auto throwScope = DECLARE_THROW_SCOPE(vm);
795     auto* prototype = jsDynamicCast<JSTestGlobalObjectPrototype*>(vm, JSValue::decode(thisValue));
796     if (UNLIKELY(!prototype)) {
797         throwVMTypeError(lexicalGlobalObject, throwScope);
798         return false;
799     }
800     // Shadowing a built-in constructor
801     return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));
802 }
803
804 static inline JSValue jsTestGlobalObjectRegularAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
805 {
806     UNUSED_PARAM(throwScope);
807     UNUSED_PARAM(lexicalGlobalObject);
808     auto& impl = thisObject.wrapped();
809     JSValue result = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.regularAttribute());
810     return result;
811 }
812
813 EncodedJSValue jsTestGlobalObjectRegularAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
814 {
815     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectRegularAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "regularAttribute");
816 }
817
818 static inline bool setJSTestGlobalObjectRegularAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
819 {
820     UNUSED_PARAM(lexicalGlobalObject);
821     UNUSED_PARAM(throwScope);
822     auto& impl = thisObject.wrapped();
823     auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
824     RETURN_IF_EXCEPTION(throwScope, false);
825     AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
826         return impl.setRegularAttribute(WTFMove(nativeValue));
827     });
828     return true;
829 }
830
831 bool setJSTestGlobalObjectRegularAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
832 {
833     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectRegularAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "regularAttribute");
834 }
835
836 static inline JSValue jsTestGlobalObjectPublicAndPrivateAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
837 {
838     UNUSED_PARAM(throwScope);
839     UNUSED_PARAM(lexicalGlobalObject);
840     auto& impl = thisObject.wrapped();
841     JSValue result = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.publicAndPrivateAttribute());
842     return result;
843 }
844
845 EncodedJSValue jsTestGlobalObjectPublicAndPrivateAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
846 {
847     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectPublicAndPrivateAttributeGetter>(*lexicalGlobalObject, thisValue, "publicAndPrivateAttribute");
848 }
849
850 static inline bool setJSTestGlobalObjectPublicAndPrivateAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
851 {
852     UNUSED_PARAM(lexicalGlobalObject);
853     UNUSED_PARAM(throwScope);
854     auto& impl = thisObject.wrapped();
855     auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
856     RETURN_IF_EXCEPTION(throwScope, false);
857     AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
858         return impl.setPublicAndPrivateAttribute(WTFMove(nativeValue));
859     });
860     return true;
861 }
862
863 bool setJSTestGlobalObjectPublicAndPrivateAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
864 {
865     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectPublicAndPrivateAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "publicAndPrivateAttribute");
866 }
867
868 #if ENABLE(TEST_FEATURE)
869 static inline JSValue jsTestGlobalObjectPublicAndPrivateConditionalAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
870 {
871     UNUSED_PARAM(throwScope);
872     UNUSED_PARAM(lexicalGlobalObject);
873     auto& impl = thisObject.wrapped();
874     JSValue result = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.publicAndPrivateConditionalAttribute());
875     return result;
876 }
877
878 EncodedJSValue jsTestGlobalObjectPublicAndPrivateConditionalAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
879 {
880     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectPublicAndPrivateConditionalAttributeGetter>(*lexicalGlobalObject, thisValue, "publicAndPrivateConditionalAttribute");
881 }
882
883 #endif
884
885 #if ENABLE(TEST_FEATURE)
886 static inline bool setJSTestGlobalObjectPublicAndPrivateConditionalAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
887 {
888     UNUSED_PARAM(lexicalGlobalObject);
889     UNUSED_PARAM(throwScope);
890     auto& impl = thisObject.wrapped();
891     auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
892     RETURN_IF_EXCEPTION(throwScope, false);
893     AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
894         return impl.setPublicAndPrivateConditionalAttribute(WTFMove(nativeValue));
895     });
896     return true;
897 }
898
899 bool setJSTestGlobalObjectPublicAndPrivateConditionalAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
900 {
901     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectPublicAndPrivateConditionalAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "publicAndPrivateConditionalAttribute");
902 }
903
904 #endif
905
906 #if ENABLE(TEST_FEATURE)
907 static inline JSValue jsTestGlobalObjectEnabledAtRuntimeAttributeGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
908 {
909     UNUSED_PARAM(throwScope);
910     UNUSED_PARAM(lexicalGlobalObject);
911     auto& impl = thisObject.wrapped();
912     JSValue result = toJS<IDLDOMString>(lexicalGlobalObject, throwScope, impl.enabledAtRuntimeAttribute());
913     return result;
914 }
915
916 EncodedJSValue jsTestGlobalObjectEnabledAtRuntimeAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
917 {
918     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectEnabledAtRuntimeAttributeGetter>(*lexicalGlobalObject, thisValue, "enabledAtRuntimeAttribute");
919 }
920
921 #endif
922
923 #if ENABLE(TEST_FEATURE)
924 static inline bool setJSTestGlobalObjectEnabledAtRuntimeAttributeSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
925 {
926     UNUSED_PARAM(lexicalGlobalObject);
927     UNUSED_PARAM(throwScope);
928     auto& impl = thisObject.wrapped();
929     auto nativeValue = convert<IDLDOMString>(lexicalGlobalObject, value);
930     RETURN_IF_EXCEPTION(throwScope, false);
931     AttributeSetter::call(lexicalGlobalObject, throwScope, [&] {
932         return impl.setEnabledAtRuntimeAttribute(WTFMove(nativeValue));
933     });
934     return true;
935 }
936
937 bool setJSTestGlobalObjectEnabledAtRuntimeAttribute(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
938 {
939     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectEnabledAtRuntimeAttributeSetter>(*lexicalGlobalObject, thisValue, encodedValue, "enabledAtRuntimeAttribute");
940 }
941
942 #endif
943
944 static inline JSValue jsTestGlobalObjectTestCEReactionsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
945 {
946     UNUSED_PARAM(throwScope);
947     UNUSED_PARAM(lexicalGlobalObject);
948     return JSTestCEReactions::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
949 }
950
951 EncodedJSValue jsTestGlobalObjectTestCEReactionsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
952 {
953     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCEReactionsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestCEReactions");
954 }
955
956 static inline bool setJSTestGlobalObjectTestCEReactionsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
957 {
958     UNUSED_PARAM(lexicalGlobalObject);
959     VM& vm = throwScope.vm();
960     // Shadowing a built-in constructor.
961     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestCEReactions"), strlen("TestCEReactions")), value);
962 }
963
964 bool setJSTestGlobalObjectTestCEReactionsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
965 {
966     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCEReactionsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestCEReactions");
967 }
968
969 static inline JSValue jsTestGlobalObjectTestCEReactionsStringifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
970 {
971     UNUSED_PARAM(throwScope);
972     UNUSED_PARAM(lexicalGlobalObject);
973     return JSTestCEReactionsStringifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
974 }
975
976 EncodedJSValue jsTestGlobalObjectTestCEReactionsStringifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
977 {
978     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCEReactionsStringifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestCEReactionsStringifier");
979 }
980
981 static inline bool setJSTestGlobalObjectTestCEReactionsStringifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
982 {
983     UNUSED_PARAM(lexicalGlobalObject);
984     VM& vm = throwScope.vm();
985     // Shadowing a built-in constructor.
986     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestCEReactionsStringifier"), strlen("TestCEReactionsStringifier")), value);
987 }
988
989 bool setJSTestGlobalObjectTestCEReactionsStringifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
990 {
991     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCEReactionsStringifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestCEReactionsStringifier");
992 }
993
994 static inline JSValue jsTestGlobalObjectTestCallTracerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
995 {
996     UNUSED_PARAM(throwScope);
997     UNUSED_PARAM(lexicalGlobalObject);
998     return JSTestCallTracer::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
999 }
1000
1001 EncodedJSValue jsTestGlobalObjectTestCallTracerConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1002 {
1003     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCallTracerConstructorGetter>(*lexicalGlobalObject, thisValue, "TestCallTracer");
1004 }
1005
1006 static inline bool setJSTestGlobalObjectTestCallTracerConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1007 {
1008     UNUSED_PARAM(lexicalGlobalObject);
1009     VM& vm = throwScope.vm();
1010     // Shadowing a built-in constructor.
1011     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestCallTracer"), strlen("TestCallTracer")), value);
1012 }
1013
1014 bool setJSTestGlobalObjectTestCallTracerConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1015 {
1016     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCallTracerConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestCallTracer");
1017 }
1018
1019 #if ENABLE(TEST_CONDITIONAL)
1020 static inline JSValue jsTestGlobalObjectTestCallbackInterfaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1021 {
1022     UNUSED_PARAM(throwScope);
1023     UNUSED_PARAM(lexicalGlobalObject);
1024     return JSTestCallbackInterface::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1025 }
1026
1027 EncodedJSValue jsTestGlobalObjectTestCallbackInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1028 {
1029     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCallbackInterfaceConstructorGetter>(*lexicalGlobalObject, thisValue, "TestCallbackInterface");
1030 }
1031
1032 #endif
1033
1034 #if ENABLE(TEST_CONDITIONAL)
1035 static inline bool setJSTestGlobalObjectTestCallbackInterfaceConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1036 {
1037     UNUSED_PARAM(lexicalGlobalObject);
1038     VM& vm = throwScope.vm();
1039     // Shadowing a built-in constructor.
1040     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestCallbackInterface"), strlen("TestCallbackInterface")), value);
1041 }
1042
1043 bool setJSTestGlobalObjectTestCallbackInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1044 {
1045     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCallbackInterfaceConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestCallbackInterface");
1046 }
1047
1048 #endif
1049
1050 static inline JSValue jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1051 {
1052     UNUSED_PARAM(throwScope);
1053     UNUSED_PARAM(lexicalGlobalObject);
1054     return JSTestClassWithJSBuiltinConstructor::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1055 }
1056
1057 EncodedJSValue jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1058 {
1059     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorGetter>(*lexicalGlobalObject, thisValue, "TestClassWithJSBuiltinConstructor");
1060 }
1061
1062 static inline bool setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1063 {
1064     UNUSED_PARAM(lexicalGlobalObject);
1065     VM& vm = throwScope.vm();
1066     // Shadowing a built-in constructor.
1067     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestClassWithJSBuiltinConstructor"), strlen("TestClassWithJSBuiltinConstructor")), value);
1068 }
1069
1070 bool setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1071 {
1072     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestClassWithJSBuiltinConstructor");
1073 }
1074
1075 static inline JSValue jsTestGlobalObjectTestDOMJITConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1076 {
1077     UNUSED_PARAM(throwScope);
1078     UNUSED_PARAM(lexicalGlobalObject);
1079     return JSTestDOMJIT::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1080 }
1081
1082 EncodedJSValue jsTestGlobalObjectTestDOMJITConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1083 {
1084     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestDOMJITConstructorGetter>(*lexicalGlobalObject, thisValue, "TestDOMJIT");
1085 }
1086
1087 static inline bool setJSTestGlobalObjectTestDOMJITConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1088 {
1089     UNUSED_PARAM(lexicalGlobalObject);
1090     VM& vm = throwScope.vm();
1091     // Shadowing a built-in constructor.
1092     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestDOMJIT"), strlen("TestDOMJIT")), value);
1093 }
1094
1095 bool setJSTestGlobalObjectTestDOMJITConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1096 {
1097     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestDOMJITConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestDOMJIT");
1098 }
1099
1100 static inline JSValue jsTestGlobalObjectTestDomainSecurityConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1101 {
1102     UNUSED_PARAM(throwScope);
1103     UNUSED_PARAM(lexicalGlobalObject);
1104     return JSTestDomainSecurity::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1105 }
1106
1107 EncodedJSValue jsTestGlobalObjectTestDomainSecurityConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1108 {
1109     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestDomainSecurityConstructorGetter>(*lexicalGlobalObject, thisValue, "TestDomainSecurity");
1110 }
1111
1112 static inline bool setJSTestGlobalObjectTestDomainSecurityConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1113 {
1114     UNUSED_PARAM(lexicalGlobalObject);
1115     VM& vm = throwScope.vm();
1116     // Shadowing a built-in constructor.
1117     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestDomainSecurity"), strlen("TestDomainSecurity")), value);
1118 }
1119
1120 bool setJSTestGlobalObjectTestDomainSecurityConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1121 {
1122     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestDomainSecurityConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestDomainSecurity");
1123 }
1124
1125 static inline JSValue jsTestGlobalObjectTestEnabledBySettingConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1126 {
1127     UNUSED_PARAM(throwScope);
1128     UNUSED_PARAM(lexicalGlobalObject);
1129     return JSTestEnabledBySetting::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1130 }
1131
1132 EncodedJSValue jsTestGlobalObjectTestEnabledBySettingConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1133 {
1134     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEnabledBySettingConstructorGetter>(*lexicalGlobalObject, thisValue, "TestEnabledBySetting");
1135 }
1136
1137 static inline bool setJSTestGlobalObjectTestEnabledBySettingConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1138 {
1139     UNUSED_PARAM(lexicalGlobalObject);
1140     VM& vm = throwScope.vm();
1141     // Shadowing a built-in constructor.
1142     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestEnabledBySetting"), strlen("TestEnabledBySetting")), value);
1143 }
1144
1145 bool setJSTestGlobalObjectTestEnabledBySettingConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1146 {
1147     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEnabledBySettingConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestEnabledBySetting");
1148 }
1149
1150 static inline JSValue jsTestGlobalObjectTestEnabledForContextConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1151 {
1152     UNUSED_PARAM(throwScope);
1153     UNUSED_PARAM(lexicalGlobalObject);
1154     return JSTestEnabledForContext::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1155 }
1156
1157 EncodedJSValue jsTestGlobalObjectTestEnabledForContextConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1158 {
1159     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEnabledForContextConstructorGetter>(*lexicalGlobalObject, thisValue, "TestEnabledForContext");
1160 }
1161
1162 static inline bool setJSTestGlobalObjectTestEnabledForContextConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1163 {
1164     UNUSED_PARAM(lexicalGlobalObject);
1165     VM& vm = throwScope.vm();
1166     // Shadowing a built-in constructor.
1167     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestEnabledForContext"), strlen("TestEnabledForContext")), value);
1168 }
1169
1170 bool setJSTestGlobalObjectTestEnabledForContextConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1171 {
1172     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEnabledForContextConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestEnabledForContext");
1173 }
1174
1175 static inline JSValue jsTestGlobalObjectTestEventConstructorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1176 {
1177     UNUSED_PARAM(throwScope);
1178     UNUSED_PARAM(lexicalGlobalObject);
1179     return JSTestEventConstructor::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1180 }
1181
1182 EncodedJSValue jsTestGlobalObjectTestEventConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1183 {
1184     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEventConstructorConstructorGetter>(*lexicalGlobalObject, thisValue, "TestEventConstructor");
1185 }
1186
1187 static inline bool setJSTestGlobalObjectTestEventConstructorConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1188 {
1189     UNUSED_PARAM(lexicalGlobalObject);
1190     VM& vm = throwScope.vm();
1191     // Shadowing a built-in constructor.
1192     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestEventConstructor"), strlen("TestEventConstructor")), value);
1193 }
1194
1195 bool setJSTestGlobalObjectTestEventConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1196 {
1197     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEventConstructorConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestEventConstructor");
1198 }
1199
1200 static inline JSValue jsTestGlobalObjectTestEventTargetConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1201 {
1202     UNUSED_PARAM(throwScope);
1203     UNUSED_PARAM(lexicalGlobalObject);
1204     return JSTestEventTarget::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1205 }
1206
1207 EncodedJSValue jsTestGlobalObjectTestEventTargetConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1208 {
1209     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEventTargetConstructorGetter>(*lexicalGlobalObject, thisValue, "TestEventTarget");
1210 }
1211
1212 static inline bool setJSTestGlobalObjectTestEventTargetConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1213 {
1214     UNUSED_PARAM(lexicalGlobalObject);
1215     VM& vm = throwScope.vm();
1216     // Shadowing a built-in constructor.
1217     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestEventTarget"), strlen("TestEventTarget")), value);
1218 }
1219
1220 bool setJSTestGlobalObjectTestEventTargetConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1221 {
1222     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEventTargetConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestEventTarget");
1223 }
1224
1225 static inline JSValue jsTestGlobalObjectTestExceptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1226 {
1227     UNUSED_PARAM(throwScope);
1228     UNUSED_PARAM(lexicalGlobalObject);
1229     return JSTestException::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1230 }
1231
1232 EncodedJSValue jsTestGlobalObjectTestExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1233 {
1234     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestExceptionConstructorGetter>(*lexicalGlobalObject, thisValue, "TestException");
1235 }
1236
1237 static inline bool setJSTestGlobalObjectTestExceptionConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1238 {
1239     UNUSED_PARAM(lexicalGlobalObject);
1240     VM& vm = throwScope.vm();
1241     // Shadowing a built-in constructor.
1242     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestException"), strlen("TestException")), value);
1243 }
1244
1245 bool setJSTestGlobalObjectTestExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1246 {
1247     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestExceptionConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestException");
1248 }
1249
1250 static inline JSValue jsTestGlobalObjectTestGenerateIsReachableConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1251 {
1252     UNUSED_PARAM(throwScope);
1253     UNUSED_PARAM(lexicalGlobalObject);
1254     return JSTestGenerateIsReachable::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1255 }
1256
1257 EncodedJSValue jsTestGlobalObjectTestGenerateIsReachableConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1258 {
1259     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestGenerateIsReachableConstructorGetter>(*lexicalGlobalObject, thisValue, "TestGenerateIsReachable");
1260 }
1261
1262 static inline bool setJSTestGlobalObjectTestGenerateIsReachableConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1263 {
1264     UNUSED_PARAM(lexicalGlobalObject);
1265     VM& vm = throwScope.vm();
1266     // Shadowing a built-in constructor.
1267     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestGenerateIsReachable"), strlen("TestGenerateIsReachable")), value);
1268 }
1269
1270 bool setJSTestGlobalObjectTestGenerateIsReachableConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1271 {
1272     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestGenerateIsReachableConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestGenerateIsReachable");
1273 }
1274
1275 static inline JSValue jsTestGlobalObjectTestGlobalObjectConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1276 {
1277     UNUSED_PARAM(throwScope);
1278     UNUSED_PARAM(lexicalGlobalObject);
1279     return JSTestGlobalObject::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1280 }
1281
1282 EncodedJSValue jsTestGlobalObjectTestGlobalObjectConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1283 {
1284     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestGlobalObjectConstructorGetter>(*lexicalGlobalObject, thisValue, "TestGlobalObject");
1285 }
1286
1287 static inline bool setJSTestGlobalObjectTestGlobalObjectConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1288 {
1289     UNUSED_PARAM(lexicalGlobalObject);
1290     VM& vm = throwScope.vm();
1291     // Shadowing a built-in constructor.
1292     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestGlobalObject"), strlen("TestGlobalObject")), value);
1293 }
1294
1295 bool setJSTestGlobalObjectTestGlobalObjectConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1296 {
1297     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestGlobalObjectConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestGlobalObject");
1298 }
1299
1300 static inline JSValue jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1301 {
1302     UNUSED_PARAM(throwScope);
1303     UNUSED_PARAM(lexicalGlobalObject);
1304     return JSTestIndexedSetterNoIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1305 }
1306
1307 EncodedJSValue jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1308 {
1309     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestIndexedSetterNoIdentifier");
1310 }
1311
1312 static inline bool setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1313 {
1314     UNUSED_PARAM(lexicalGlobalObject);
1315     VM& vm = throwScope.vm();
1316     // Shadowing a built-in constructor.
1317     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestIndexedSetterNoIdentifier"), strlen("TestIndexedSetterNoIdentifier")), value);
1318 }
1319
1320 bool setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1321 {
1322     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestIndexedSetterNoIdentifier");
1323 }
1324
1325 static inline JSValue jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1326 {
1327     UNUSED_PARAM(throwScope);
1328     UNUSED_PARAM(lexicalGlobalObject);
1329     return JSTestIndexedSetterThrowingException::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1330 }
1331
1332 EncodedJSValue jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1333 {
1334     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorGetter>(*lexicalGlobalObject, thisValue, "TestIndexedSetterThrowingException");
1335 }
1336
1337 static inline bool setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1338 {
1339     UNUSED_PARAM(lexicalGlobalObject);
1340     VM& vm = throwScope.vm();
1341     // Shadowing a built-in constructor.
1342     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestIndexedSetterThrowingException"), strlen("TestIndexedSetterThrowingException")), value);
1343 }
1344
1345 bool setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1346 {
1347     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestIndexedSetterThrowingException");
1348 }
1349
1350 static inline JSValue jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1351 {
1352     UNUSED_PARAM(throwScope);
1353     UNUSED_PARAM(lexicalGlobalObject);
1354     return JSTestIndexedSetterWithIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1355 }
1356
1357 EncodedJSValue jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1358 {
1359     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestIndexedSetterWithIdentifier");
1360 }
1361
1362 static inline bool setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1363 {
1364     UNUSED_PARAM(lexicalGlobalObject);
1365     VM& vm = throwScope.vm();
1366     // Shadowing a built-in constructor.
1367     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestIndexedSetterWithIdentifier"), strlen("TestIndexedSetterWithIdentifier")), value);
1368 }
1369
1370 bool setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1371 {
1372     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestIndexedSetterWithIdentifier");
1373 }
1374
1375 #if ENABLE(Condition1) || ENABLE(Condition2)
1376 static inline JSValue jsTestGlobalObjectTestInterfaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1377 {
1378     UNUSED_PARAM(throwScope);
1379     UNUSED_PARAM(lexicalGlobalObject);
1380     return JSTestInterface::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1381 }
1382
1383 EncodedJSValue jsTestGlobalObjectTestInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1384 {
1385     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestInterfaceConstructorGetter>(*lexicalGlobalObject, thisValue, "TestInterface");
1386 }
1387
1388 #endif
1389
1390 #if ENABLE(Condition1) || ENABLE(Condition2)
1391 static inline bool setJSTestGlobalObjectTestInterfaceConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1392 {
1393     UNUSED_PARAM(lexicalGlobalObject);
1394     VM& vm = throwScope.vm();
1395     // Shadowing a built-in constructor.
1396     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestInterface"), strlen("TestInterface")), value);
1397 }
1398
1399 bool setJSTestGlobalObjectTestInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1400 {
1401     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestInterfaceConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestInterface");
1402 }
1403
1404 #endif
1405
1406 static inline JSValue jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1407 {
1408     UNUSED_PARAM(throwScope);
1409     UNUSED_PARAM(lexicalGlobalObject);
1410     return JSTestInterfaceLeadingUnderscore::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1411 }
1412
1413 EncodedJSValue jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1414 {
1415     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorGetter>(*lexicalGlobalObject, thisValue, "TestInterfaceLeadingUnderscore");
1416 }
1417
1418 static inline bool setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1419 {
1420     UNUSED_PARAM(lexicalGlobalObject);
1421     VM& vm = throwScope.vm();
1422     // Shadowing a built-in constructor.
1423     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestInterfaceLeadingUnderscore"), strlen("TestInterfaceLeadingUnderscore")), value);
1424 }
1425
1426 bool setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1427 {
1428     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestInterfaceLeadingUnderscore");
1429 }
1430
1431 static inline JSValue jsTestGlobalObjectTestIterableConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1432 {
1433     UNUSED_PARAM(throwScope);
1434     UNUSED_PARAM(lexicalGlobalObject);
1435     return JSTestIterable::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1436 }
1437
1438 EncodedJSValue jsTestGlobalObjectTestIterableConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1439 {
1440     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIterableConstructorGetter>(*lexicalGlobalObject, thisValue, "TestIterable");
1441 }
1442
1443 static inline bool setJSTestGlobalObjectTestIterableConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1444 {
1445     UNUSED_PARAM(lexicalGlobalObject);
1446     VM& vm = throwScope.vm();
1447     // Shadowing a built-in constructor.
1448     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestIterable"), strlen("TestIterable")), value);
1449 }
1450
1451 bool setJSTestGlobalObjectTestIterableConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1452 {
1453     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIterableConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestIterable");
1454 }
1455
1456 static inline JSValue jsTestGlobalObjectTestJSBuiltinConstructorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1457 {
1458     UNUSED_PARAM(throwScope);
1459     UNUSED_PARAM(lexicalGlobalObject);
1460     return JSTestJSBuiltinConstructor::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1461 }
1462
1463 EncodedJSValue jsTestGlobalObjectTestJSBuiltinConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1464 {
1465     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestJSBuiltinConstructorConstructorGetter>(*lexicalGlobalObject, thisValue, "TestJSBuiltinConstructor");
1466 }
1467
1468 static inline bool setJSTestGlobalObjectTestJSBuiltinConstructorConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1469 {
1470     UNUSED_PARAM(lexicalGlobalObject);
1471     VM& vm = throwScope.vm();
1472     // Shadowing a built-in constructor.
1473     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestJSBuiltinConstructor"), strlen("TestJSBuiltinConstructor")), value);
1474 }
1475
1476 bool setJSTestGlobalObjectTestJSBuiltinConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1477 {
1478     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestJSBuiltinConstructorConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestJSBuiltinConstructor");
1479 }
1480
1481 static inline JSValue jsTestGlobalObjectTestMapLikeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1482 {
1483     UNUSED_PARAM(throwScope);
1484     UNUSED_PARAM(lexicalGlobalObject);
1485     return JSTestMapLike::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1486 }
1487
1488 EncodedJSValue jsTestGlobalObjectTestMapLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1489 {
1490     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestMapLikeConstructorGetter>(*lexicalGlobalObject, thisValue, "TestMapLike");
1491 }
1492
1493 static inline bool setJSTestGlobalObjectTestMapLikeConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1494 {
1495     UNUSED_PARAM(lexicalGlobalObject);
1496     VM& vm = throwScope.vm();
1497     // Shadowing a built-in constructor.
1498     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestMapLike"), strlen("TestMapLike")), value);
1499 }
1500
1501 bool setJSTestGlobalObjectTestMapLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1502 {
1503     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestMapLikeConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestMapLike");
1504 }
1505
1506 static inline JSValue jsTestGlobalObjectTestMediaQueryListListenerConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1507 {
1508     UNUSED_PARAM(throwScope);
1509     UNUSED_PARAM(lexicalGlobalObject);
1510     return JSTestMediaQueryListListener::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1511 }
1512
1513 EncodedJSValue jsTestGlobalObjectTestMediaQueryListListenerConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1514 {
1515     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestMediaQueryListListenerConstructorGetter>(*lexicalGlobalObject, thisValue, "TestMediaQueryListListener");
1516 }
1517
1518 static inline bool setJSTestGlobalObjectTestMediaQueryListListenerConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1519 {
1520     UNUSED_PARAM(lexicalGlobalObject);
1521     VM& vm = throwScope.vm();
1522     // Shadowing a built-in constructor.
1523     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestMediaQueryListListener"), strlen("TestMediaQueryListListener")), value);
1524 }
1525
1526 bool setJSTestGlobalObjectTestMediaQueryListListenerConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1527 {
1528     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestMediaQueryListListenerConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestMediaQueryListListener");
1529 }
1530
1531 static inline JSValue jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1532 {
1533     UNUSED_PARAM(throwScope);
1534     UNUSED_PARAM(lexicalGlobalObject);
1535     return JSTestNamedAndIndexedSetterNoIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1536 }
1537
1538 EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1539 {
1540     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedAndIndexedSetterNoIdentifier");
1541 }
1542
1543 static inline bool setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1544 {
1545     UNUSED_PARAM(lexicalGlobalObject);
1546     VM& vm = throwScope.vm();
1547     // Shadowing a built-in constructor.
1548     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedAndIndexedSetterNoIdentifier"), strlen("TestNamedAndIndexedSetterNoIdentifier")), value);
1549 }
1550
1551 bool setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1552 {
1553     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedAndIndexedSetterNoIdentifier");
1554 }
1555
1556 static inline JSValue jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1557 {
1558     UNUSED_PARAM(throwScope);
1559     UNUSED_PARAM(lexicalGlobalObject);
1560     return JSTestNamedAndIndexedSetterThrowingException::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1561 }
1562
1563 EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1564 {
1565     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedAndIndexedSetterThrowingException");
1566 }
1567
1568 static inline bool setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1569 {
1570     UNUSED_PARAM(lexicalGlobalObject);
1571     VM& vm = throwScope.vm();
1572     // Shadowing a built-in constructor.
1573     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedAndIndexedSetterThrowingException"), strlen("TestNamedAndIndexedSetterThrowingException")), value);
1574 }
1575
1576 bool setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1577 {
1578     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedAndIndexedSetterThrowingException");
1579 }
1580
1581 static inline JSValue jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1582 {
1583     UNUSED_PARAM(throwScope);
1584     UNUSED_PARAM(lexicalGlobalObject);
1585     return JSTestNamedAndIndexedSetterWithIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1586 }
1587
1588 EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1589 {
1590     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedAndIndexedSetterWithIdentifier");
1591 }
1592
1593 static inline bool setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1594 {
1595     UNUSED_PARAM(lexicalGlobalObject);
1596     VM& vm = throwScope.vm();
1597     // Shadowing a built-in constructor.
1598     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedAndIndexedSetterWithIdentifier"), strlen("TestNamedAndIndexedSetterWithIdentifier")), value);
1599 }
1600
1601 bool setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1602 {
1603     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedAndIndexedSetterWithIdentifier");
1604 }
1605
1606 static inline JSValue jsTestGlobalObjectTestNamedConstructorConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1607 {
1608     UNUSED_PARAM(throwScope);
1609     UNUSED_PARAM(lexicalGlobalObject);
1610     return JSTestNamedConstructor::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1611 }
1612
1613 EncodedJSValue jsTestGlobalObjectTestNamedConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1614 {
1615     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedConstructorConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedConstructor");
1616 }
1617
1618 static inline bool setJSTestGlobalObjectTestNamedConstructorConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1619 {
1620     UNUSED_PARAM(lexicalGlobalObject);
1621     VM& vm = throwScope.vm();
1622     // Shadowing a built-in constructor.
1623     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedConstructor"), strlen("TestNamedConstructor")), value);
1624 }
1625
1626 bool setJSTestGlobalObjectTestNamedConstructorConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1627 {
1628     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedConstructorConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedConstructor");
1629 }
1630
1631 static inline JSValue jsTestGlobalObjectAudioConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1632 {
1633     UNUSED_PARAM(throwScope);
1634     UNUSED_PARAM(lexicalGlobalObject);
1635     return JSTestNamedConstructorNamed::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1636 }
1637
1638 EncodedJSValue jsTestGlobalObjectAudioConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1639 {
1640     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectAudioConstructorGetter>(*lexicalGlobalObject, thisValue, "Audio");
1641 }
1642
1643 static inline bool setJSTestGlobalObjectAudioConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1644 {
1645     UNUSED_PARAM(lexicalGlobalObject);
1646     VM& vm = throwScope.vm();
1647     // Shadowing a built-in constructor.
1648     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("Audio"), strlen("Audio")), value);
1649 }
1650
1651 bool setJSTestGlobalObjectAudioConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1652 {
1653     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectAudioConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "Audio");
1654 }
1655
1656 static inline JSValue jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1657 {
1658     UNUSED_PARAM(throwScope);
1659     UNUSED_PARAM(lexicalGlobalObject);
1660     return JSTestNamedDeleterNoIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1661 }
1662
1663 EncodedJSValue jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1664 {
1665     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedDeleterNoIdentifier");
1666 }
1667
1668 static inline bool setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1669 {
1670     UNUSED_PARAM(lexicalGlobalObject);
1671     VM& vm = throwScope.vm();
1672     // Shadowing a built-in constructor.
1673     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedDeleterNoIdentifier"), strlen("TestNamedDeleterNoIdentifier")), value);
1674 }
1675
1676 bool setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1677 {
1678     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedDeleterNoIdentifier");
1679 }
1680
1681 static inline JSValue jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1682 {
1683     UNUSED_PARAM(throwScope);
1684     UNUSED_PARAM(lexicalGlobalObject);
1685     return JSTestNamedDeleterThrowingException::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1686 }
1687
1688 EncodedJSValue jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1689 {
1690     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedDeleterThrowingException");
1691 }
1692
1693 static inline bool setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1694 {
1695     UNUSED_PARAM(lexicalGlobalObject);
1696     VM& vm = throwScope.vm();
1697     // Shadowing a built-in constructor.
1698     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedDeleterThrowingException"), strlen("TestNamedDeleterThrowingException")), value);
1699 }
1700
1701 bool setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1702 {
1703     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedDeleterThrowingException");
1704 }
1705
1706 static inline JSValue jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1707 {
1708     UNUSED_PARAM(throwScope);
1709     UNUSED_PARAM(lexicalGlobalObject);
1710     return JSTestNamedDeleterWithIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1711 }
1712
1713 EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1714 {
1715     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedDeleterWithIdentifier");
1716 }
1717
1718 static inline bool setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1719 {
1720     UNUSED_PARAM(lexicalGlobalObject);
1721     VM& vm = throwScope.vm();
1722     // Shadowing a built-in constructor.
1723     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedDeleterWithIdentifier"), strlen("TestNamedDeleterWithIdentifier")), value);
1724 }
1725
1726 bool setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1727 {
1728     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedDeleterWithIdentifier");
1729 }
1730
1731 static inline JSValue jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1732 {
1733     UNUSED_PARAM(throwScope);
1734     UNUSED_PARAM(lexicalGlobalObject);
1735     return JSTestNamedDeleterWithIndexedGetter::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1736 }
1737
1738 EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1739 {
1740     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedDeleterWithIndexedGetter");
1741 }
1742
1743 static inline bool setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1744 {
1745     UNUSED_PARAM(lexicalGlobalObject);
1746     VM& vm = throwScope.vm();
1747     // Shadowing a built-in constructor.
1748     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedDeleterWithIndexedGetter"), strlen("TestNamedDeleterWithIndexedGetter")), value);
1749 }
1750
1751 bool setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1752 {
1753     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedDeleterWithIndexedGetter");
1754 }
1755
1756 static inline JSValue jsTestGlobalObjectTestNamedGetterCallWithConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1757 {
1758     UNUSED_PARAM(throwScope);
1759     UNUSED_PARAM(lexicalGlobalObject);
1760     return JSTestNamedGetterCallWith::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1761 }
1762
1763 EncodedJSValue jsTestGlobalObjectTestNamedGetterCallWithConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1764 {
1765     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedGetterCallWithConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedGetterCallWith");
1766 }
1767
1768 static inline bool setJSTestGlobalObjectTestNamedGetterCallWithConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1769 {
1770     UNUSED_PARAM(lexicalGlobalObject);
1771     VM& vm = throwScope.vm();
1772     // Shadowing a built-in constructor.
1773     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedGetterCallWith"), strlen("TestNamedGetterCallWith")), value);
1774 }
1775
1776 bool setJSTestGlobalObjectTestNamedGetterCallWithConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1777 {
1778     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedGetterCallWithConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedGetterCallWith");
1779 }
1780
1781 static inline JSValue jsTestGlobalObjectTestNamedGetterNoIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1782 {
1783     UNUSED_PARAM(throwScope);
1784     UNUSED_PARAM(lexicalGlobalObject);
1785     return JSTestNamedGetterNoIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1786 }
1787
1788 EncodedJSValue jsTestGlobalObjectTestNamedGetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1789 {
1790     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedGetterNoIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedGetterNoIdentifier");
1791 }
1792
1793 static inline bool setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1794 {
1795     UNUSED_PARAM(lexicalGlobalObject);
1796     VM& vm = throwScope.vm();
1797     // Shadowing a built-in constructor.
1798     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedGetterNoIdentifier"), strlen("TestNamedGetterNoIdentifier")), value);
1799 }
1800
1801 bool setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1802 {
1803     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedGetterNoIdentifier");
1804 }
1805
1806 static inline JSValue jsTestGlobalObjectTestNamedGetterWithIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1807 {
1808     UNUSED_PARAM(throwScope);
1809     UNUSED_PARAM(lexicalGlobalObject);
1810     return JSTestNamedGetterWithIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1811 }
1812
1813 EncodedJSValue jsTestGlobalObjectTestNamedGetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1814 {
1815     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedGetterWithIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedGetterWithIdentifier");
1816 }
1817
1818 static inline bool setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1819 {
1820     UNUSED_PARAM(lexicalGlobalObject);
1821     VM& vm = throwScope.vm();
1822     // Shadowing a built-in constructor.
1823     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedGetterWithIdentifier"), strlen("TestNamedGetterWithIdentifier")), value);
1824 }
1825
1826 bool setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1827 {
1828     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedGetterWithIdentifier");
1829 }
1830
1831 static inline JSValue jsTestGlobalObjectTestNamedSetterNoIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1832 {
1833     UNUSED_PARAM(throwScope);
1834     UNUSED_PARAM(lexicalGlobalObject);
1835     return JSTestNamedSetterNoIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1836 }
1837
1838 EncodedJSValue jsTestGlobalObjectTestNamedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1839 {
1840     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterNoIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterNoIdentifier");
1841 }
1842
1843 static inline bool setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1844 {
1845     UNUSED_PARAM(lexicalGlobalObject);
1846     VM& vm = throwScope.vm();
1847     // Shadowing a built-in constructor.
1848     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterNoIdentifier"), strlen("TestNamedSetterNoIdentifier")), value);
1849 }
1850
1851 bool setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1852 {
1853     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterNoIdentifier");
1854 }
1855
1856 static inline JSValue jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1857 {
1858     UNUSED_PARAM(throwScope);
1859     UNUSED_PARAM(lexicalGlobalObject);
1860     return JSTestNamedSetterThrowingException::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1861 }
1862
1863 EncodedJSValue jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1864 {
1865     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterThrowingException");
1866 }
1867
1868 static inline bool setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1869 {
1870     UNUSED_PARAM(lexicalGlobalObject);
1871     VM& vm = throwScope.vm();
1872     // Shadowing a built-in constructor.
1873     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterThrowingException"), strlen("TestNamedSetterThrowingException")), value);
1874 }
1875
1876 bool setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1877 {
1878     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterThrowingException");
1879 }
1880
1881 static inline JSValue jsTestGlobalObjectTestNamedSetterWithIdentifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1882 {
1883     UNUSED_PARAM(throwScope);
1884     UNUSED_PARAM(lexicalGlobalObject);
1885     return JSTestNamedSetterWithIdentifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1886 }
1887
1888 EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1889 {
1890     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithIdentifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterWithIdentifier");
1891 }
1892
1893 static inline bool setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1894 {
1895     UNUSED_PARAM(lexicalGlobalObject);
1896     VM& vm = throwScope.vm();
1897     // Shadowing a built-in constructor.
1898     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterWithIdentifier"), strlen("TestNamedSetterWithIdentifier")), value);
1899 }
1900
1901 bool setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1902 {
1903     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterWithIdentifier");
1904 }
1905
1906 static inline JSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1907 {
1908     UNUSED_PARAM(throwScope);
1909     UNUSED_PARAM(lexicalGlobalObject);
1910     return JSTestNamedSetterWithIndexedGetter::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1911 }
1912
1913 EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1914 {
1915     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterWithIndexedGetter");
1916 }
1917
1918 static inline bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1919 {
1920     UNUSED_PARAM(lexicalGlobalObject);
1921     VM& vm = throwScope.vm();
1922     // Shadowing a built-in constructor.
1923     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterWithIndexedGetter"), strlen("TestNamedSetterWithIndexedGetter")), value);
1924 }
1925
1926 bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1927 {
1928     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterWithIndexedGetter");
1929 }
1930
1931 static inline JSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1932 {
1933     UNUSED_PARAM(throwScope);
1934     UNUSED_PARAM(lexicalGlobalObject);
1935     return JSTestNamedSetterWithIndexedGetterAndSetter::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1936 }
1937
1938 EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1939 {
1940     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterWithIndexedGetterAndSetter");
1941 }
1942
1943 static inline bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1944 {
1945     UNUSED_PARAM(lexicalGlobalObject);
1946     VM& vm = throwScope.vm();
1947     // Shadowing a built-in constructor.
1948     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterWithIndexedGetterAndSetter"), strlen("TestNamedSetterWithIndexedGetterAndSetter")), value);
1949 }
1950
1951 bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1952 {
1953     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterWithIndexedGetterAndSetter");
1954 }
1955
1956 static inline JSValue jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1957 {
1958     UNUSED_PARAM(throwScope);
1959     UNUSED_PARAM(lexicalGlobalObject);
1960     return JSTestNamedSetterWithOverrideBuiltins::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1961 }
1962
1963 EncodedJSValue jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1964 {
1965     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterWithOverrideBuiltins");
1966 }
1967
1968 static inline bool setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1969 {
1970     UNUSED_PARAM(lexicalGlobalObject);
1971     VM& vm = throwScope.vm();
1972     // Shadowing a built-in constructor.
1973     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterWithOverrideBuiltins"), strlen("TestNamedSetterWithOverrideBuiltins")), value);
1974 }
1975
1976 bool setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
1977 {
1978     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterWithOverrideBuiltins");
1979 }
1980
1981 static inline JSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
1982 {
1983     UNUSED_PARAM(throwScope);
1984     UNUSED_PARAM(lexicalGlobalObject);
1985     return JSTestNamedSetterWithUnforgableProperties::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
1986 }
1987
1988 EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
1989 {
1990     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterWithUnforgableProperties");
1991 }
1992
1993 static inline bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
1994 {
1995     UNUSED_PARAM(lexicalGlobalObject);
1996     VM& vm = throwScope.vm();
1997     // Shadowing a built-in constructor.
1998     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterWithUnforgableProperties"), strlen("TestNamedSetterWithUnforgableProperties")), value);
1999 }
2000
2001 bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2002 {
2003     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterWithUnforgableProperties");
2004 }
2005
2006 static inline JSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2007 {
2008     UNUSED_PARAM(throwScope);
2009     UNUSED_PARAM(lexicalGlobalObject);
2010     return JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2011 }
2012
2013 EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2014 {
2015     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins");
2016 }
2017
2018 static inline bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2019 {
2020     UNUSED_PARAM(lexicalGlobalObject);
2021     VM& vm = throwScope.vm();
2022     // Shadowing a built-in constructor.
2023     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins"), strlen("TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins")), value);
2024 }
2025
2026 bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2027 {
2028     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins");
2029 }
2030
2031 static inline JSValue jsTestGlobalObjectTestOverloadedConstructorsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2032 {
2033     UNUSED_PARAM(throwScope);
2034     UNUSED_PARAM(lexicalGlobalObject);
2035     return JSTestOverloadedConstructors::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2036 }
2037
2038 EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2039 {
2040     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestOverloadedConstructorsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestOverloadedConstructors");
2041 }
2042
2043 static inline bool setJSTestGlobalObjectTestOverloadedConstructorsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2044 {
2045     UNUSED_PARAM(lexicalGlobalObject);
2046     VM& vm = throwScope.vm();
2047     // Shadowing a built-in constructor.
2048     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestOverloadedConstructors"), strlen("TestOverloadedConstructors")), value);
2049 }
2050
2051 bool setJSTestGlobalObjectTestOverloadedConstructorsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2052 {
2053     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestOverloadedConstructorsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestOverloadedConstructors");
2054 }
2055
2056 static inline JSValue jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2057 {
2058     UNUSED_PARAM(throwScope);
2059     UNUSED_PARAM(lexicalGlobalObject);
2060     return JSTestOverloadedConstructorsWithSequence::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2061 }
2062
2063 EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2064 {
2065     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorGetter>(*lexicalGlobalObject, thisValue, "TestOverloadedConstructorsWithSequence");
2066 }
2067
2068 static inline bool setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2069 {
2070     UNUSED_PARAM(lexicalGlobalObject);
2071     VM& vm = throwScope.vm();
2072     // Shadowing a built-in constructor.
2073     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestOverloadedConstructorsWithSequence"), strlen("TestOverloadedConstructorsWithSequence")), value);
2074 }
2075
2076 bool setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2077 {
2078     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestOverloadedConstructorsWithSequence");
2079 }
2080
2081 static inline JSValue jsTestGlobalObjectTestOverrideBuiltinsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2082 {
2083     UNUSED_PARAM(throwScope);
2084     UNUSED_PARAM(lexicalGlobalObject);
2085     return JSTestOverrideBuiltins::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2086 }
2087
2088 EncodedJSValue jsTestGlobalObjectTestOverrideBuiltinsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2089 {
2090     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestOverrideBuiltinsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestOverrideBuiltins");
2091 }
2092
2093 static inline bool setJSTestGlobalObjectTestOverrideBuiltinsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2094 {
2095     UNUSED_PARAM(lexicalGlobalObject);
2096     VM& vm = throwScope.vm();
2097     // Shadowing a built-in constructor.
2098     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestOverrideBuiltins"), strlen("TestOverrideBuiltins")), value);
2099 }
2100
2101 bool setJSTestGlobalObjectTestOverrideBuiltinsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2102 {
2103     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestOverrideBuiltinsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestOverrideBuiltins");
2104 }
2105
2106 static inline JSValue jsTestGlobalObjectTestPluginInterfaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2107 {
2108     UNUSED_PARAM(throwScope);
2109     UNUSED_PARAM(lexicalGlobalObject);
2110     return JSTestPluginInterface::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2111 }
2112
2113 EncodedJSValue jsTestGlobalObjectTestPluginInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2114 {
2115     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestPluginInterfaceConstructorGetter>(*lexicalGlobalObject, thisValue, "TestPluginInterface");
2116 }
2117
2118 static inline bool setJSTestGlobalObjectTestPluginInterfaceConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2119 {
2120     UNUSED_PARAM(lexicalGlobalObject);
2121     VM& vm = throwScope.vm();
2122     // Shadowing a built-in constructor.
2123     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestPluginInterface"), strlen("TestPluginInterface")), value);
2124 }
2125
2126 bool setJSTestGlobalObjectTestPluginInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2127 {
2128     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestPluginInterfaceConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestPluginInterface");
2129 }
2130
2131 static inline JSValue jsTestGlobalObjectTestReadOnlyMapLikeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2132 {
2133     UNUSED_PARAM(throwScope);
2134     UNUSED_PARAM(lexicalGlobalObject);
2135     return JSTestReadOnlyMapLike::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2136 }
2137
2138 EncodedJSValue jsTestGlobalObjectTestReadOnlyMapLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2139 {
2140     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestReadOnlyMapLikeConstructorGetter>(*lexicalGlobalObject, thisValue, "TestReadOnlyMapLike");
2141 }
2142
2143 static inline bool setJSTestGlobalObjectTestReadOnlyMapLikeConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2144 {
2145     UNUSED_PARAM(lexicalGlobalObject);
2146     VM& vm = throwScope.vm();
2147     // Shadowing a built-in constructor.
2148     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestReadOnlyMapLike"), strlen("TestReadOnlyMapLike")), value);
2149 }
2150
2151 bool setJSTestGlobalObjectTestReadOnlyMapLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2152 {
2153     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestReadOnlyMapLikeConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestReadOnlyMapLike");
2154 }
2155
2156 static inline JSValue jsTestGlobalObjectTestReadOnlySetLikeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2157 {
2158     UNUSED_PARAM(throwScope);
2159     UNUSED_PARAM(lexicalGlobalObject);
2160     return JSTestReadOnlySetLike::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2161 }
2162
2163 EncodedJSValue jsTestGlobalObjectTestReadOnlySetLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2164 {
2165     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestReadOnlySetLikeConstructorGetter>(*lexicalGlobalObject, thisValue, "TestReadOnlySetLike");
2166 }
2167
2168 static inline bool setJSTestGlobalObjectTestReadOnlySetLikeConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2169 {
2170     UNUSED_PARAM(lexicalGlobalObject);
2171     VM& vm = throwScope.vm();
2172     // Shadowing a built-in constructor.
2173     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestReadOnlySetLike"), strlen("TestReadOnlySetLike")), value);
2174 }
2175
2176 bool setJSTestGlobalObjectTestReadOnlySetLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2177 {
2178     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestReadOnlySetLikeConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestReadOnlySetLike");
2179 }
2180
2181 static inline JSValue jsTestGlobalObjectTestReportExtraMemoryCostConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2182 {
2183     UNUSED_PARAM(throwScope);
2184     UNUSED_PARAM(lexicalGlobalObject);
2185     return JSTestReportExtraMemoryCost::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2186 }
2187
2188 EncodedJSValue jsTestGlobalObjectTestReportExtraMemoryCostConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2189 {
2190     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestReportExtraMemoryCostConstructorGetter>(*lexicalGlobalObject, thisValue, "TestReportExtraMemoryCost");
2191 }
2192
2193 static inline bool setJSTestGlobalObjectTestReportExtraMemoryCostConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2194 {
2195     UNUSED_PARAM(lexicalGlobalObject);
2196     VM& vm = throwScope.vm();
2197     // Shadowing a built-in constructor.
2198     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestReportExtraMemoryCost"), strlen("TestReportExtraMemoryCost")), value);
2199 }
2200
2201 bool setJSTestGlobalObjectTestReportExtraMemoryCostConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2202 {
2203     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestReportExtraMemoryCostConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestReportExtraMemoryCost");
2204 }
2205
2206 static inline JSValue jsTestGlobalObjectTestSerializationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2207 {
2208     UNUSED_PARAM(throwScope);
2209     UNUSED_PARAM(lexicalGlobalObject);
2210     return JSTestSerialization::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2211 }
2212
2213 EncodedJSValue jsTestGlobalObjectTestSerializationConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2214 {
2215     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationConstructorGetter>(*lexicalGlobalObject, thisValue, "TestSerialization");
2216 }
2217
2218 static inline bool setJSTestGlobalObjectTestSerializationConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2219 {
2220     UNUSED_PARAM(lexicalGlobalObject);
2221     VM& vm = throwScope.vm();
2222     // Shadowing a built-in constructor.
2223     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestSerialization"), strlen("TestSerialization")), value);
2224 }
2225
2226 bool setJSTestGlobalObjectTestSerializationConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2227 {
2228     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSerialization");
2229 }
2230
2231 static inline JSValue jsTestGlobalObjectTestSerializationIndirectInheritanceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2232 {
2233     UNUSED_PARAM(throwScope);
2234     UNUSED_PARAM(lexicalGlobalObject);
2235     return JSTestSerializationIndirectInheritance::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2236 }
2237
2238 EncodedJSValue jsTestGlobalObjectTestSerializationIndirectInheritanceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2239 {
2240     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationIndirectInheritanceConstructorGetter>(*lexicalGlobalObject, thisValue, "TestSerializationIndirectInheritance");
2241 }
2242
2243 static inline bool setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2244 {
2245     UNUSED_PARAM(lexicalGlobalObject);
2246     VM& vm = throwScope.vm();
2247     // Shadowing a built-in constructor.
2248     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestSerializationIndirectInheritance"), strlen("TestSerializationIndirectInheritance")), value);
2249 }
2250
2251 bool setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2252 {
2253     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSerializationIndirectInheritance");
2254 }
2255
2256 static inline JSValue jsTestGlobalObjectTestSerializationInheritConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2257 {
2258     UNUSED_PARAM(throwScope);
2259     UNUSED_PARAM(lexicalGlobalObject);
2260     return JSTestSerializationInherit::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2261 }
2262
2263 EncodedJSValue jsTestGlobalObjectTestSerializationInheritConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2264 {
2265     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationInheritConstructorGetter>(*lexicalGlobalObject, thisValue, "TestSerializationInherit");
2266 }
2267
2268 static inline bool setJSTestGlobalObjectTestSerializationInheritConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2269 {
2270     UNUSED_PARAM(lexicalGlobalObject);
2271     VM& vm = throwScope.vm();
2272     // Shadowing a built-in constructor.
2273     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestSerializationInherit"), strlen("TestSerializationInherit")), value);
2274 }
2275
2276 bool setJSTestGlobalObjectTestSerializationInheritConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2277 {
2278     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationInheritConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSerializationInherit");
2279 }
2280
2281 static inline JSValue jsTestGlobalObjectTestSerializationInheritFinalConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2282 {
2283     UNUSED_PARAM(throwScope);
2284     UNUSED_PARAM(lexicalGlobalObject);
2285     return JSTestSerializationInheritFinal::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2286 }
2287
2288 EncodedJSValue jsTestGlobalObjectTestSerializationInheritFinalConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2289 {
2290     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationInheritFinalConstructorGetter>(*lexicalGlobalObject, thisValue, "TestSerializationInheritFinal");
2291 }
2292
2293 static inline bool setJSTestGlobalObjectTestSerializationInheritFinalConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2294 {
2295     UNUSED_PARAM(lexicalGlobalObject);
2296     VM& vm = throwScope.vm();
2297     // Shadowing a built-in constructor.
2298     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestSerializationInheritFinal"), strlen("TestSerializationInheritFinal")), value);
2299 }
2300
2301 bool setJSTestGlobalObjectTestSerializationInheritFinalConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2302 {
2303     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationInheritFinalConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSerializationInheritFinal");
2304 }
2305
2306 #if ENABLE(Condition1) || ENABLE(Condition2)
2307 static inline JSValue jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2308 {
2309     UNUSED_PARAM(throwScope);
2310     UNUSED_PARAM(lexicalGlobalObject);
2311     return JSTestSerializedScriptValueInterface::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2312 }
2313
2314 EncodedJSValue jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2315 {
2316     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructorGetter>(*lexicalGlobalObject, thisValue, "TestSerializedScriptValueInterface");
2317 }
2318
2319 #endif
2320
2321 #if ENABLE(Condition1) || ENABLE(Condition2)
2322 static inline bool setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2323 {
2324     UNUSED_PARAM(lexicalGlobalObject);
2325     VM& vm = throwScope.vm();
2326     // Shadowing a built-in constructor.
2327     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestSerializedScriptValueInterface"), strlen("TestSerializedScriptValueInterface")), value);
2328 }
2329
2330 bool setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2331 {
2332     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSerializedScriptValueInterface");
2333 }
2334
2335 #endif
2336
2337 static inline JSValue jsTestGlobalObjectTestSetLikeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2338 {
2339     UNUSED_PARAM(throwScope);
2340     UNUSED_PARAM(lexicalGlobalObject);
2341     return JSTestSetLike::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2342 }
2343
2344 EncodedJSValue jsTestGlobalObjectTestSetLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2345 {
2346     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSetLikeConstructorGetter>(*lexicalGlobalObject, thisValue, "TestSetLike");
2347 }
2348
2349 static inline bool setJSTestGlobalObjectTestSetLikeConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2350 {
2351     UNUSED_PARAM(lexicalGlobalObject);
2352     VM& vm = throwScope.vm();
2353     // Shadowing a built-in constructor.
2354     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestSetLike"), strlen("TestSetLike")), value);
2355 }
2356
2357 bool setJSTestGlobalObjectTestSetLikeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2358 {
2359     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSetLikeConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSetLike");
2360 }
2361
2362 static inline JSValue jsTestGlobalObjectTestStringifierConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2363 {
2364     UNUSED_PARAM(throwScope);
2365     UNUSED_PARAM(lexicalGlobalObject);
2366     return JSTestStringifier::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2367 }
2368
2369 EncodedJSValue jsTestGlobalObjectTestStringifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2370 {
2371     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifier");
2372 }
2373
2374 static inline bool setJSTestGlobalObjectTestStringifierConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2375 {
2376     UNUSED_PARAM(lexicalGlobalObject);
2377     VM& vm = throwScope.vm();
2378     // Shadowing a built-in constructor.
2379     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifier"), strlen("TestStringifier")), value);
2380 }
2381
2382 bool setJSTestGlobalObjectTestStringifierConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2383 {
2384     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifier");
2385 }
2386
2387 static inline JSValue jsTestGlobalObjectTestStringifierAnonymousOperationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2388 {
2389     UNUSED_PARAM(throwScope);
2390     UNUSED_PARAM(lexicalGlobalObject);
2391     return JSTestStringifierAnonymousOperation::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2392 }
2393
2394 EncodedJSValue jsTestGlobalObjectTestStringifierAnonymousOperationConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2395 {
2396     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierAnonymousOperationConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifierAnonymousOperation");
2397 }
2398
2399 static inline bool setJSTestGlobalObjectTestStringifierAnonymousOperationConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2400 {
2401     UNUSED_PARAM(lexicalGlobalObject);
2402     VM& vm = throwScope.vm();
2403     // Shadowing a built-in constructor.
2404     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifierAnonymousOperation"), strlen("TestStringifierAnonymousOperation")), value);
2405 }
2406
2407 bool setJSTestGlobalObjectTestStringifierAnonymousOperationConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2408 {
2409     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierAnonymousOperationConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifierAnonymousOperation");
2410 }
2411
2412 static inline JSValue jsTestGlobalObjectTestStringifierNamedOperationConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2413 {
2414     UNUSED_PARAM(throwScope);
2415     UNUSED_PARAM(lexicalGlobalObject);
2416     return JSTestStringifierNamedOperation::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2417 }
2418
2419 EncodedJSValue jsTestGlobalObjectTestStringifierNamedOperationConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2420 {
2421     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierNamedOperationConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifierNamedOperation");
2422 }
2423
2424 static inline bool setJSTestGlobalObjectTestStringifierNamedOperationConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2425 {
2426     UNUSED_PARAM(lexicalGlobalObject);
2427     VM& vm = throwScope.vm();
2428     // Shadowing a built-in constructor.
2429     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifierNamedOperation"), strlen("TestStringifierNamedOperation")), value);
2430 }
2431
2432 bool setJSTestGlobalObjectTestStringifierNamedOperationConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2433 {
2434     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierNamedOperationConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifierNamedOperation");
2435 }
2436
2437 static inline JSValue jsTestGlobalObjectTestStringifierOperationImplementedAsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2438 {
2439     UNUSED_PARAM(throwScope);
2440     UNUSED_PARAM(lexicalGlobalObject);
2441     return JSTestStringifierOperationImplementedAs::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2442 }
2443
2444 EncodedJSValue jsTestGlobalObjectTestStringifierOperationImplementedAsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2445 {
2446     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierOperationImplementedAsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifierOperationImplementedAs");
2447 }
2448
2449 static inline bool setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2450 {
2451     UNUSED_PARAM(lexicalGlobalObject);
2452     VM& vm = throwScope.vm();
2453     // Shadowing a built-in constructor.
2454     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifierOperationImplementedAs"), strlen("TestStringifierOperationImplementedAs")), value);
2455 }
2456
2457 bool setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2458 {
2459     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifierOperationImplementedAs");
2460 }
2461
2462 static inline JSValue jsTestGlobalObjectTestStringifierOperationNamedToStringConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2463 {
2464     UNUSED_PARAM(throwScope);
2465     UNUSED_PARAM(lexicalGlobalObject);
2466     return JSTestStringifierOperationNamedToString::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2467 }
2468
2469 EncodedJSValue jsTestGlobalObjectTestStringifierOperationNamedToStringConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2470 {
2471     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierOperationNamedToStringConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifierOperationNamedToString");
2472 }
2473
2474 static inline bool setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2475 {
2476     UNUSED_PARAM(lexicalGlobalObject);
2477     VM& vm = throwScope.vm();
2478     // Shadowing a built-in constructor.
2479     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifierOperationNamedToString"), strlen("TestStringifierOperationNamedToString")), value);
2480 }
2481
2482 bool setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2483 {
2484     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifierOperationNamedToString");
2485 }
2486
2487 static inline JSValue jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2488 {
2489     UNUSED_PARAM(throwScope);
2490     UNUSED_PARAM(lexicalGlobalObject);
2491     return JSTestStringifierReadOnlyAttribute::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2492 }
2493
2494 EncodedJSValue jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2495 {
2496     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifierReadOnlyAttribute");
2497 }
2498
2499 static inline bool setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2500 {
2501     UNUSED_PARAM(lexicalGlobalObject);
2502     VM& vm = throwScope.vm();
2503     // Shadowing a built-in constructor.
2504     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifierReadOnlyAttribute"), strlen("TestStringifierReadOnlyAttribute")), value);
2505 }
2506
2507 bool setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2508 {
2509     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifierReadOnlyAttribute");
2510 }
2511
2512 static inline JSValue jsTestGlobalObjectTestStringifierReadWriteAttributeConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2513 {
2514     UNUSED_PARAM(throwScope);
2515     UNUSED_PARAM(lexicalGlobalObject);
2516     return JSTestStringifierReadWriteAttribute::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2517 }
2518
2519 EncodedJSValue jsTestGlobalObjectTestStringifierReadWriteAttributeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2520 {
2521     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierReadWriteAttributeConstructorGetter>(*lexicalGlobalObject, thisValue, "TestStringifierReadWriteAttribute");
2522 }
2523
2524 static inline bool setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2525 {
2526     UNUSED_PARAM(lexicalGlobalObject);
2527     VM& vm = throwScope.vm();
2528     // Shadowing a built-in constructor.
2529     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestStringifierReadWriteAttribute"), strlen("TestStringifierReadWriteAttribute")), value);
2530 }
2531
2532 bool setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2533 {
2534     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestStringifierReadWriteAttribute");
2535 }
2536
2537 static inline JSValue jsTestGlobalObjectTestTypedefsConstructorGetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
2538 {
2539     UNUSED_PARAM(throwScope);
2540     UNUSED_PARAM(lexicalGlobalObject);
2541     return JSTestTypedefs::getConstructor(JSC::getVM(&lexicalGlobalObject), thisObject.globalObject());
2542 }
2543
2544 EncodedJSValue jsTestGlobalObjectTestTypedefsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, PropertyName)
2545 {
2546     return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestTypedefsConstructorGetter>(*lexicalGlobalObject, thisValue, "TestTypedefs");
2547 }
2548
2549 static inline bool setJSTestGlobalObjectTestTypedefsConstructorSetter(JSGlobalObject& lexicalGlobalObject, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
2550 {
2551     UNUSED_PARAM(lexicalGlobalObject);
2552     VM& vm = throwScope.vm();
2553     // Shadowing a built-in constructor.
2554     return thisObject.putDirect(vm, Identifier::fromString(vm, reinterpret_cast<const LChar*>("TestTypedefs"), strlen("TestTypedefs")), value);
2555 }
2556
2557 bool setJSTestGlobalObjectTestTypedefsConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2558 {
2559     return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestTypedefsConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestTypedefs");
2560 }
2561
2562 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionRegularOperationBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2563 {
2564     UNUSED_PARAM(lexicalGlobalObject);
2565     UNUSED_PARAM(callFrame);
2566     UNUSED_PARAM(throwScope);
2567     auto& impl = castedThis->wrapped();
2568     if (UNLIKELY(callFrame->argumentCount() < 1))
2569         return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
2570     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2571     auto testParam = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
2572     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2573     impl.regularOperation(WTFMove(testParam));
2574     return JSValue::encode(jsUndefined());
2575 }
2576
2577 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionRegularOperation(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2578 {
2579     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionRegularOperationBody>(*lexicalGlobalObject, *callFrame, "regularOperation");
2580 }
2581
2582 #if ENABLE(TEST_FEATURE)
2583 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation1Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2584 {
2585     UNUSED_PARAM(lexicalGlobalObject);
2586     UNUSED_PARAM(callFrame);
2587     UNUSED_PARAM(throwScope);
2588     auto& impl = castedThis->wrapped();
2589     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2590     auto testParam = convert<IDLDOMString>(*lexicalGlobalObject, argument0.value());
2591     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2592     impl.enabledAtRuntimeOperation(WTFMove(testParam));
2593     return JSValue::encode(jsUndefined());
2594 }
2595
2596 #endif
2597
2598 #if ENABLE(TEST_FEATURE)
2599 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation2Body(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2600 {
2601     UNUSED_PARAM(lexicalGlobalObject);
2602     UNUSED_PARAM(callFrame);
2603     UNUSED_PARAM(throwScope);
2604     auto& impl = castedThis->wrapped();
2605     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2606     auto testParam = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
2607     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2608     impl.enabledAtRuntimeOperation(WTFMove(testParam));
2609     return JSValue::encode(jsUndefined());
2610 }
2611
2612 #endif
2613
2614 #if ENABLE(TEST_FEATURE)
2615
2616 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperationOverloadDispatcher(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2617 {
2618     UNUSED_PARAM(lexicalGlobalObject);
2619     UNUSED_PARAM(callFrame);
2620     UNUSED_PARAM(throwScope);
2621     VM& vm = JSC::getVM(lexicalGlobalObject);
2622     UNUSED_PARAM(vm);
2623     size_t argsCount = std::min<size_t>(1, callFrame->argumentCount());
2624     if (argsCount == 1) {
2625         JSValue distinguishingArg = callFrame->uncheckedArgument(0);
2626 #if ENABLE(TEST_FEATURE)
2627         if (distinguishingArg.isNumber())
2628             return jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation2Body(lexicalGlobalObject, callFrame, castedThis, throwScope);
2629 #endif
2630 #if ENABLE(TEST_FEATURE)
2631         return jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation1Body(lexicalGlobalObject, callFrame, castedThis, throwScope);
2632 #endif
2633     }
2634     return argsCount < 1 ? throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject)) : throwVMTypeError(lexicalGlobalObject, throwScope);
2635 }
2636
2637 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperation(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2638 {
2639     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionEnabledAtRuntimeOperationOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "enabledAtRuntimeOperation");
2640 }
2641
2642 #endif
2643
2644 #if ENABLE(TEST_FEATURE)
2645 static inline JSC::EncodedJSValue jsTestGlobalObjectConstructorFunctionEnabledAtRuntimeOperationStaticBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, JSC::ThrowScope& throwScope)
2646 {
2647     UNUSED_PARAM(lexicalGlobalObject);
2648     UNUSED_PARAM(callFrame);
2649     UNUSED_PARAM(throwScope);
2650     if (UNLIKELY(callFrame->argumentCount() < 1))
2651         return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
2652     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2653     auto testParam = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
2654     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2655     TestGlobalObject::enabledAtRuntimeOperationStatic(WTFMove(testParam));
2656     return JSValue::encode(jsUndefined());
2657 }
2658
2659 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectConstructorFunctionEnabledAtRuntimeOperationStatic(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2660 {
2661     return IDLOperation<JSTestGlobalObject>::callStatic<jsTestGlobalObjectConstructorFunctionEnabledAtRuntimeOperationStaticBody>(*lexicalGlobalObject, *callFrame, "enabledAtRuntimeOperationStatic");
2662 }
2663
2664 #endif
2665
2666 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2667 {
2668     UNUSED_PARAM(lexicalGlobalObject);
2669     UNUSED_PARAM(callFrame);
2670     UNUSED_PARAM(throwScope);
2671     auto& impl = castedThis->wrapped();
2672     if (UNLIKELY(callFrame->argumentCount() < 1))
2673         return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
2674     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2675     auto testParam = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
2676     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2677     impl.enabledInSpecificWorld(WTFMove(testParam));
2678     return JSValue::encode(jsUndefined());
2679 }
2680
2681 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorld(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2682 {
2683     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldBody>(*lexicalGlobalObject, *callFrame, "enabledInSpecificWorld");
2684 }
2685
2686 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeatureEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2687 {
2688     UNUSED_PARAM(lexicalGlobalObject);
2689     UNUSED_PARAM(callFrame);
2690     UNUSED_PARAM(throwScope);
2691     auto& impl = castedThis->wrapped();
2692     if (UNLIKELY(callFrame->argumentCount() < 1))
2693         return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
2694     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2695     auto testParam = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
2696     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2697     impl.enabledInSpecificWorldWhenRuntimeFeatureEnabled(WTFMove(testParam));
2698     return JSValue::encode(jsUndefined());
2699 }
2700
2701 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeatureEnabled(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2702 {
2703     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeatureEnabledBody>(*lexicalGlobalObject, *callFrame, "enabledInSpecificWorldWhenRuntimeFeatureEnabled");
2704 }
2705
2706 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeaturesEnabledBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2707 {
2708     UNUSED_PARAM(lexicalGlobalObject);
2709     UNUSED_PARAM(callFrame);
2710     UNUSED_PARAM(throwScope);
2711     auto& impl = castedThis->wrapped();
2712     if (UNLIKELY(callFrame->argumentCount() < 1))
2713         return throwVMError(lexicalGlobalObject, throwScope, createNotEnoughArgumentsError(lexicalGlobalObject));
2714     EnsureStillAliveScope argument0 = callFrame->uncheckedArgument(0);
2715     auto testParam = convert<IDLLong>(*lexicalGlobalObject, argument0.value());
2716     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
2717     impl.enabledInSpecificWorldWhenRuntimeFeaturesEnabled(WTFMove(testParam));
2718     return JSValue::encode(jsUndefined());
2719 }
2720
2721 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeaturesEnabled(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2722 {
2723     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionEnabledInSpecificWorldWhenRuntimeFeaturesEnabledBody>(*lexicalGlobalObject, *callFrame, "enabledInSpecificWorldWhenRuntimeFeaturesEnabled");
2724 }
2725
2726 #if ENABLE(TEST_FEATURE)
2727 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionTestPrivateFunctionBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2728 {
2729     UNUSED_PARAM(lexicalGlobalObject);
2730     UNUSED_PARAM(callFrame);
2731     UNUSED_PARAM(throwScope);
2732     auto& impl = castedThis->wrapped();
2733     impl.testPrivateFunction();
2734     return JSValue::encode(jsUndefined());
2735 }
2736
2737 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionTestPrivateFunction(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2738 {
2739     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionTestPrivateFunctionBody, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, *callFrame, "testPrivateFunction");
2740 }
2741
2742 #endif
2743
2744 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionCalculateSecretResultBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperationReturningPromise<JSTestGlobalObject>::ClassParameter castedThis, Ref<DeferredPromise>&& promise, JSC::ThrowScope& throwScope)
2745 {
2746     UNUSED_PARAM(lexicalGlobalObject);
2747     UNUSED_PARAM(callFrame);
2748     UNUSED_PARAM(throwScope);
2749     auto& impl = castedThis->wrapped();
2750     impl.calculateSecretResult(WTFMove(promise));
2751     return JSValue::encode(jsUndefined());
2752 }
2753
2754 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionCalculateSecretResult(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2755 {
2756     return IDLOperationReturningPromise<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionCalculateSecretResultBody>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
2757 }
2758
2759 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionGetSecretBooleanBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2760 {
2761     UNUSED_PARAM(lexicalGlobalObject);
2762     UNUSED_PARAM(callFrame);
2763     UNUSED_PARAM(throwScope);
2764     auto& impl = castedThis->wrapped();
2765     auto result = JSValue::encode(toJS<IDLBoolean>(impl.getSecretBoolean()));
2766     return result;
2767 }
2768
2769 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionGetSecretBoolean(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2770 {
2771     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionGetSecretBooleanBody>(*lexicalGlobalObject, *callFrame, "getSecretBoolean");
2772 }
2773
2774 #if ENABLE(TEST_FEATURE)
2775 static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionTestFeatureGetSecretBooleanBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
2776 {
2777     UNUSED_PARAM(lexicalGlobalObject);
2778     UNUSED_PARAM(callFrame);
2779     UNUSED_PARAM(throwScope);
2780     auto& impl = castedThis->wrapped();
2781     auto result = JSValue::encode(toJS<IDLBoolean>(impl.testFeatureGetSecretBoolean()));
2782     return result;
2783 }
2784
2785 EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionTestFeatureGetSecretBoolean(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
2786 {
2787     return IDLOperation<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionTestFeatureGetSecretBooleanBody>(*lexicalGlobalObject, *callFrame, "testFeatureGetSecretBoolean");
2788 }
2789
2790 #endif
2791
2792 JSC::IsoSubspace* JSTestGlobalObject::subspaceForImpl(JSC::VM& vm)
2793 {
2794     auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);
2795     auto& spaces = clientData.subspaces();
2796     if (auto* space = spaces.m_subspaceForTestGlobalObject.get())
2797         return space;
2798     spaces.m_subspaceForTestGlobalObject = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, clientData.m_heapCellTypeForJSTestGlobalObject.get(), JSTestGlobalObject);
2799     auto* space = spaces.m_subspaceForTestGlobalObject.get();
2800 IGNORE_WARNINGS_BEGIN("unreachable-code")
2801 IGNORE_WARNINGS_BEGIN("tautological-compare")
2802     if (&JSTestGlobalObject::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)
2803         clientData.outputConstraintSpaces().append(space);
2804 IGNORE_WARNINGS_END
2805 IGNORE_WARNINGS_END
2806     return space;
2807 }
2808
2809 void JSTestGlobalObject::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
2810 {
2811     auto* thisObject = jsCast<JSTestGlobalObject*>(cell);
2812     analyzer.setWrappedObjectForCell(cell, &thisObject->wrapped());
2813     if (thisObject->scriptExecutionContext())
2814         analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
2815     Base::analyzeHeap(cell, analyzer);
2816 }
2817
2818 bool JSTestGlobalObjectOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor, const char** reason)
2819 {
2820     UNUSED_PARAM(handle);
2821     UNUSED_PARAM(visitor);
2822     UNUSED_PARAM(reason);
2823     return false;
2824 }
2825
2826 void JSTestGlobalObjectOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
2827 {
2828     auto* jsTestGlobalObject = static_cast<JSTestGlobalObject*>(handle.slot()->asCell());
2829     auto& world = *static_cast<DOMWrapperWorld*>(context);
2830     uncacheWrapper(world, &jsTestGlobalObject->wrapped(), jsTestGlobalObject);
2831 }
2832
2833 #if ENABLE(BINDING_INTEGRITY)
2834 #if PLATFORM(WIN)
2835 #pragma warning(disable: 4483)
2836 extern "C" { extern void (*const __identifier("??_7TestGlobalObject@WebCore@@6B@")[])(); }
2837 #else
2838 extern "C" { extern void* _ZTVN7WebCore16TestGlobalObjectE[]; }
2839 #endif
2840 #endif
2841
2842 JSC::JSValue toJSNewlyCreated(JSC::JSGlobalObject*, JSDOMGlobalObject* globalObject, Ref<TestGlobalObject>&& impl)
2843 {
2844
2845 #if ENABLE(BINDING_INTEGRITY)
2846     const void* actualVTablePointer = getVTablePointer(impl.ptr());
2847 #if PLATFORM(WIN)
2848     void* expectedVTablePointer = __identifier("??_7TestGlobalObject@WebCore@@6B@");
2849 #else
2850     void* expectedVTablePointer = &_ZTVN7WebCore16TestGlobalObjectE[2];
2851 #endif
2852
2853     // If this fails TestGlobalObject does not have a vtable, so you need to add the
2854     // ImplementationLacksVTable attribute to the interface definition
2855     static_assert(std::is_polymorphic<TestGlobalObject>::value, "TestGlobalObject is not polymorphic");
2856
2857     // If you hit this assertion you either have a use after free bug, or
2858     // TestGlobalObject has subclasses. If TestGlobalObject has subclasses that get passed
2859     // to toJS() we currently require TestGlobalObject you to opt out of binding hardening
2860     // by adding the SkipVTableValidation attribute to the interface IDL definition
2861     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
2862 #endif
2863     return createWrapper<TestGlobalObject>(globalObject, WTFMove(impl));
2864 }
2865
2866 JSC::JSValue toJS(JSC::JSGlobalObject* lexicalGlobalObject, JSDOMGlobalObject* globalObject, TestGlobalObject& impl)
2867 {
2868     return wrap(lexicalGlobalObject, globalObject, impl);
2869 }
2870
2871 TestGlobalObject* JSTestGlobalObject::toWrapped(JSC::VM& vm, JSC::JSValue value)
2872 {
2873     if (auto* wrapper = jsDynamicCast<JSTestGlobalObject*>(vm, value))
2874         return &wrapper->wrapped();
2875     return nullptr;
2876 }
2877
2878 }