Next step on dictionary bindings, along with other bindings refinements
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestObj.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 "JSTestObj.h"
23
24 #include "CallbackFunction.h"
25 #include "DOMStringList.h"
26 #include "Dictionary.h"
27 #include "Document.h"
28 #include "ExceptionCode.h"
29 #include "Frame.h"
30 #include "HTMLNames.h"
31 #include "JSDOMBinding.h"
32 #include "JSDOMConstructor.h"
33 #include "JSDOMConvert.h"
34 #include "JSDOMIterator.h"
35 #include "JSDOMPromise.h"
36 #include "JSDOMStringList.h"
37 #include "JSDocument.h"
38 #include "JSEventListener.h"
39 #include "JSFetchRequest.h"
40 #include "JSNode.h"
41 #include "JSSVGDocument.h"
42 #include "JSSVGPoint.h"
43 #include "JSScriptProfile.h"
44 #include "JSTestCallback.h"
45 #include "JSTestCallbackFunction.h"
46 #include "JSTestNode.h"
47 #include "JSTestObj.h"
48 #include "JSTestSubObj.h"
49 #include "LifecycleCallbackQueue.h"
50 #include "RuntimeEnabledFeatures.h"
51 #include "SVGDocument.h"
52 #include "SVGPoint.h"
53 #include "SVGStaticPropertyTearOff.h"
54 #include "ScriptProfile.h"
55 #include "SerializedScriptValue.h"
56 #include "Settings.h"
57 #include "TestObj.h"
58 #include "URL.h"
59 #include "WebCoreJSClientData.h"
60 #include <inspector/ScriptArguments.h>
61 #include <inspector/ScriptCallStackFactory.h>
62 #include <runtime/Error.h>
63 #include <runtime/FunctionPrototype.h>
64 #include <runtime/JSArray.h>
65 #include <runtime/JSString.h>
66 #include <runtime/PropertyNameArray.h>
67 #include <wtf/GetPtr.h>
68
69 #if ENABLE(Condition1)
70 #include "JSTestObjectA.h"
71 #endif
72
73 #if ENABLE(Condition1) && ENABLE(Condition2)
74 #include "JSTestObjectB.h"
75 #endif
76
77 #if ENABLE(Condition1) || ENABLE(Condition2)
78 #include "JSTestObjectC.h"
79 #endif
80
81 #if ENABLE(Condition3) || ENABLE(Condition4)
82 #include "TestObjBuiltins.h"
83 #endif
84
85 using namespace JSC;
86
87 namespace WebCore {
88
89 template<typename T> Optional<T> parse(ExecState&, JSValue);
90 template<typename T> const char* expectedEnumerationValues();
91
92 JSString* jsStringWithCache(ExecState*, TestObj::EnumType);
93 JSString* jsStringWithCache(ExecState* state, TestObj::EnumType enumerationValue)
94 {
95     static NeverDestroyed<const String> values[] = {
96         emptyString(),
97         ASCIILiteral("EnumValue1"),
98         ASCIILiteral("EnumValue2"),
99         ASCIILiteral("EnumValue3"),
100     };
101     static_assert(static_cast<size_t>(TestObj::EnumType::EmptyString) == 0, "TestObj::EnumType::EmptyString is not 0 as expected");
102     static_assert(static_cast<size_t>(TestObj::EnumType::EnumValue1) == 1, "TestObj::EnumType::EnumValue1 is not 1 as expected");
103     static_assert(static_cast<size_t>(TestObj::EnumType::EnumValue2) == 2, "TestObj::EnumType::EnumValue2 is not 2 as expected");
104     static_assert(static_cast<size_t>(TestObj::EnumType::EnumValue3) == 3, "TestObj::EnumType::EnumValue3 is not 3 as expected");
105     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
106     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
107 }
108
109 template<> struct JSValueTraits<TestObj::EnumType> {
110     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumType value) { return jsStringWithCache(state, value); }
111 };
112
113 template<> Optional<TestObj::EnumType> parse<TestObj::EnumType>(ExecState& state, JSValue value)
114 {
115     auto stringValue = value.toWTFString(&state);
116     if (stringValue.isEmpty())
117         return TestObj::EnumType::EmptyString;
118     if (stringValue == "EnumValue1")
119         return TestObj::EnumType::EnumValue1;
120     if (stringValue == "EnumValue2")
121         return TestObj::EnumType::EnumValue2;
122     if (stringValue == "EnumValue3")
123         return TestObj::EnumType::EnumValue3;
124     return Nullopt;
125 }
126
127 template<> TestObj::EnumType convert<TestObj::EnumType>(ExecState& state, JSValue value)
128 {
129     auto result = parse<TestObj::EnumType>(state, value);
130     if (UNLIKELY(!result)) {
131         throwTypeError(&state);
132         return { };
133     }
134     return result.value();
135 }
136
137 template<> inline const char* expectedEnumerationValues<TestObj::EnumType>()
138 {
139     return "\"\", \"EnumValue1\", \"EnumValue2\", \"EnumValue3\"";
140 }
141
142 JSString* jsStringWithCache(ExecState*, TestObj::Optional);
143 JSString* jsStringWithCache(ExecState* state, TestObj::Optional enumerationValue)
144 {
145     static NeverDestroyed<const String> values[] = {
146         emptyString(),
147         ASCIILiteral("OptionalValue1"),
148         ASCIILiteral("OptionalValue2"),
149         ASCIILiteral("OptionalValue3"),
150     };
151     static_assert(static_cast<size_t>(TestObj::Optional::EmptyString) == 0, "TestObj::Optional::EmptyString is not 0 as expected");
152     static_assert(static_cast<size_t>(TestObj::Optional::OptionalValue1) == 1, "TestObj::Optional::OptionalValue1 is not 1 as expected");
153     static_assert(static_cast<size_t>(TestObj::Optional::OptionalValue2) == 2, "TestObj::Optional::OptionalValue2 is not 2 as expected");
154     static_assert(static_cast<size_t>(TestObj::Optional::OptionalValue3) == 3, "TestObj::Optional::OptionalValue3 is not 3 as expected");
155     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
156     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
157 }
158
159 template<> struct JSValueTraits<TestObj::Optional> {
160     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Optional value) { return jsStringWithCache(state, value); }
161 };
162
163 template<> Optional<TestObj::Optional> parse<TestObj::Optional>(ExecState& state, JSValue value)
164 {
165     auto stringValue = value.toWTFString(&state);
166     if (stringValue.isEmpty())
167         return TestObj::Optional::EmptyString;
168     if (stringValue == "OptionalValue1")
169         return TestObj::Optional::OptionalValue1;
170     if (stringValue == "OptionalValue2")
171         return TestObj::Optional::OptionalValue2;
172     if (stringValue == "OptionalValue3")
173         return TestObj::Optional::OptionalValue3;
174     return Nullopt;
175 }
176
177 template<> TestObj::Optional convert<TestObj::Optional>(ExecState& state, JSValue value)
178 {
179     auto result = parse<TestObj::Optional>(state, value);
180     if (UNLIKELY(!result)) {
181         throwTypeError(&state);
182         return { };
183     }
184     return result.value();
185 }
186
187 template<> inline const char* expectedEnumerationValues<TestObj::Optional>()
188 {
189     return "\"\", \"OptionalValue1\", \"OptionalValue2\", \"OptionalValue3\"";
190 }
191
192 #if ENABLE(Condition1)
193
194 JSString* jsStringWithCache(ExecState*, TestObj::EnumA);
195 JSString* jsStringWithCache(ExecState* state, TestObj::EnumA enumerationValue)
196 {
197     static NeverDestroyed<const String> values[] = {
198         ASCIILiteral("A"),
199     };
200     static_assert(static_cast<size_t>(TestObj::EnumA::A) == 0, "TestObj::EnumA::A is not 0 as expected");
201     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
202     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
203 }
204
205 template<> struct JSValueTraits<TestObj::EnumA> {
206     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumA value) { return jsStringWithCache(state, value); }
207 };
208
209 template<> Optional<TestObj::EnumA> parse<TestObj::EnumA>(ExecState& state, JSValue value)
210 {
211     auto stringValue = value.toWTFString(&state);
212     if (stringValue == "A")
213         return TestObj::EnumA::A;
214     return Nullopt;
215 }
216
217 template<> TestObj::EnumA convert<TestObj::EnumA>(ExecState& state, JSValue value)
218 {
219     auto result = parse<TestObj::EnumA>(state, value);
220     if (UNLIKELY(!result)) {
221         throwTypeError(&state);
222         return { };
223     }
224     return result.value();
225 }
226
227 template<> inline const char* expectedEnumerationValues<TestObj::EnumA>()
228 {
229     return "\"A\"";
230 }
231
232 #endif
233
234 #if ENABLE(Condition1) && ENABLE(Condition2)
235
236 JSString* jsStringWithCache(ExecState*, TestObj::EnumB);
237 JSString* jsStringWithCache(ExecState* state, TestObj::EnumB enumerationValue)
238 {
239     static NeverDestroyed<const String> values[] = {
240         ASCIILiteral("B"),
241     };
242     static_assert(static_cast<size_t>(TestObj::EnumB::B) == 0, "TestObj::EnumB::B is not 0 as expected");
243     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
244     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
245 }
246
247 template<> struct JSValueTraits<TestObj::EnumB> {
248     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumB value) { return jsStringWithCache(state, value); }
249 };
250
251 template<> Optional<TestObj::EnumB> parse<TestObj::EnumB>(ExecState& state, JSValue value)
252 {
253     auto stringValue = value.toWTFString(&state);
254     if (stringValue == "B")
255         return TestObj::EnumB::B;
256     return Nullopt;
257 }
258
259 template<> TestObj::EnumB convert<TestObj::EnumB>(ExecState& state, JSValue value)
260 {
261     auto result = parse<TestObj::EnumB>(state, value);
262     if (UNLIKELY(!result)) {
263         throwTypeError(&state);
264         return { };
265     }
266     return result.value();
267 }
268
269 template<> inline const char* expectedEnumerationValues<TestObj::EnumB>()
270 {
271     return "\"B\"";
272 }
273
274 #endif
275
276 #if ENABLE(Condition1) || ENABLE(Condition2)
277
278 JSString* jsStringWithCache(ExecState*, TestObj::EnumC);
279 JSString* jsStringWithCache(ExecState* state, TestObj::EnumC enumerationValue)
280 {
281     static NeverDestroyed<const String> values[] = {
282         ASCIILiteral("C"),
283     };
284     static_assert(static_cast<size_t>(TestObj::EnumC::C) == 0, "TestObj::EnumC::C is not 0 as expected");
285     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
286     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
287 }
288
289 template<> struct JSValueTraits<TestObj::EnumC> {
290     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::EnumC value) { return jsStringWithCache(state, value); }
291 };
292
293 template<> Optional<TestObj::EnumC> parse<TestObj::EnumC>(ExecState& state, JSValue value)
294 {
295     auto stringValue = value.toWTFString(&state);
296     if (stringValue == "C")
297         return TestObj::EnumC::C;
298     return Nullopt;
299 }
300
301 template<> TestObj::EnumC convert<TestObj::EnumC>(ExecState& state, JSValue value)
302 {
303     auto result = parse<TestObj::EnumC>(state, value);
304     if (UNLIKELY(!result)) {
305         throwTypeError(&state);
306         return { };
307     }
308     return result.value();
309 }
310
311 template<> inline const char* expectedEnumerationValues<TestObj::EnumC>()
312 {
313     return "\"C\"";
314 }
315
316 #endif
317
318 JSString* jsStringWithCache(ExecState*, TestObj::Kind);
319 JSString* jsStringWithCache(ExecState* state, TestObj::Kind enumerationValue)
320 {
321     static NeverDestroyed<const String> values[] = {
322         ASCIILiteral("quick"),
323         ASCIILiteral("dead"),
324     };
325     static_assert(static_cast<size_t>(TestObj::Kind::Quick) == 0, "TestObj::Kind::Quick is not 0 as expected");
326     static_assert(static_cast<size_t>(TestObj::Kind::Dead) == 1, "TestObj::Kind::Dead is not 1 as expected");
327     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
328     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
329 }
330
331 template<> struct JSValueTraits<TestObj::Kind> {
332     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Kind value) { return jsStringWithCache(state, value); }
333 };
334
335 template<> Optional<TestObj::Kind> parse<TestObj::Kind>(ExecState& state, JSValue value)
336 {
337     auto stringValue = value.toWTFString(&state);
338     if (stringValue == "quick")
339         return TestObj::Kind::Quick;
340     if (stringValue == "dead")
341         return TestObj::Kind::Dead;
342     return Nullopt;
343 }
344
345 template<> TestObj::Kind convert<TestObj::Kind>(ExecState& state, JSValue value)
346 {
347     auto result = parse<TestObj::Kind>(state, value);
348     if (UNLIKELY(!result)) {
349         throwTypeError(&state);
350         return { };
351     }
352     return result.value();
353 }
354
355 template<> inline const char* expectedEnumerationValues<TestObj::Kind>()
356 {
357     return "\"quick\", \"dead\"";
358 }
359
360 JSString* jsStringWithCache(ExecState*, TestObj::Size);
361 JSString* jsStringWithCache(ExecState* state, TestObj::Size enumerationValue)
362 {
363     static NeverDestroyed<const String> values[] = {
364         ASCIILiteral("small"),
365         ASCIILiteral("much-much-larger"),
366     };
367     static_assert(static_cast<size_t>(TestObj::Size::Small) == 0, "TestObj::Size::Small is not 0 as expected");
368     static_assert(static_cast<size_t>(TestObj::Size::MuchMuchLarger) == 1, "TestObj::Size::MuchMuchLarger is not 1 as expected");
369     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
370     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
371 }
372
373 template<> struct JSValueTraits<TestObj::Size> {
374     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Size value) { return jsStringWithCache(state, value); }
375 };
376
377 template<> Optional<TestObj::Size> parse<TestObj::Size>(ExecState& state, JSValue value)
378 {
379     auto stringValue = value.toWTFString(&state);
380     if (stringValue == "small")
381         return TestObj::Size::Small;
382     if (stringValue == "much-much-larger")
383         return TestObj::Size::MuchMuchLarger;
384     return Nullopt;
385 }
386
387 template<> TestObj::Size convert<TestObj::Size>(ExecState& state, JSValue value)
388 {
389     auto result = parse<TestObj::Size>(state, value);
390     if (UNLIKELY(!result)) {
391         throwTypeError(&state);
392         return { };
393     }
394     return result.value();
395 }
396
397 template<> inline const char* expectedEnumerationValues<TestObj::Size>()
398 {
399     return "\"small\", \"much-much-larger\"";
400 }
401
402 JSString* jsStringWithCache(ExecState*, TestObj::Confidence);
403 JSString* jsStringWithCache(ExecState* state, TestObj::Confidence enumerationValue)
404 {
405     static NeverDestroyed<const String> values[] = {
406         ASCIILiteral("high"),
407         ASCIILiteral("kinda-low"),
408     };
409     static_assert(static_cast<size_t>(TestObj::Confidence::High) == 0, "TestObj::Confidence::High is not 0 as expected");
410     static_assert(static_cast<size_t>(TestObj::Confidence::KindaLow) == 1, "TestObj::Confidence::KindaLow is not 1 as expected");
411     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
412     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
413 }
414
415 template<> struct JSValueTraits<TestObj::Confidence> {
416     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::Confidence value) { return jsStringWithCache(state, value); }
417 };
418
419 template<> Optional<TestObj::Confidence> parse<TestObj::Confidence>(ExecState& state, JSValue value)
420 {
421     auto stringValue = value.toWTFString(&state);
422     if (stringValue == "high")
423         return TestObj::Confidence::High;
424     if (stringValue == "kinda-low")
425         return TestObj::Confidence::KindaLow;
426     return Nullopt;
427 }
428
429 template<> TestObj::Confidence convert<TestObj::Confidence>(ExecState& state, JSValue value)
430 {
431     auto result = parse<TestObj::Confidence>(state, value);
432     if (UNLIKELY(!result)) {
433         throwTypeError(&state);
434         return { };
435     }
436     return result.value();
437 }
438
439 template<> inline const char* expectedEnumerationValues<TestObj::Confidence>()
440 {
441     return "\"high\", \"kinda-low\"";
442 }
443
444 JSString* jsStringWithCache(ExecState*, TestObj::ShadowRootMode);
445 JSString* jsStringWithCache(ExecState* state, TestObj::ShadowRootMode enumerationValue)
446 {
447     static NeverDestroyed<const String> values[] = {
448         ASCIILiteral("open"),
449         ASCIILiteral("closed"),
450     };
451     static_assert(static_cast<size_t>(TestObj::ShadowRootMode::Open) == 0, "TestObj::ShadowRootMode::Open is not 0 as expected");
452     static_assert(static_cast<size_t>(TestObj::ShadowRootMode::Closed) == 1, "TestObj::ShadowRootMode::Closed is not 1 as expected");
453     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
454     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
455 }
456
457 template<> struct JSValueTraits<TestObj::ShadowRootMode> {
458     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestObj::ShadowRootMode value) { return jsStringWithCache(state, value); }
459 };
460
461 template<> Optional<TestObj::ShadowRootMode> parse<TestObj::ShadowRootMode>(ExecState& state, JSValue value)
462 {
463     auto stringValue = value.toWTFString(&state);
464     if (stringValue == "open")
465         return TestObj::ShadowRootMode::Open;
466     if (stringValue == "closed")
467         return TestObj::ShadowRootMode::Closed;
468     return Nullopt;
469 }
470
471 template<> TestObj::ShadowRootMode convert<TestObj::ShadowRootMode>(ExecState& state, JSValue value)
472 {
473     auto result = parse<TestObj::ShadowRootMode>(state, value);
474     if (UNLIKELY(!result)) {
475         throwTypeError(&state);
476         return { };
477     }
478     return result.value();
479 }
480
481 template<> inline const char* expectedEnumerationValues<TestObj::ShadowRootMode>()
482 {
483     return "\"open\", \"closed\"";
484 }
485
486 template<> TestObj::ShadowRootInit convert<TestObj::ShadowRootInit>(ExecState& state, JSValue value)
487 {
488     auto mode = convert<TestObj::ShadowRootMode>(state, propertyValue(state, value, "mode"));
489     return { WTFMove(mode) };
490 }
491
492 template<> TestObj::FontFaceDescriptors convert<TestObj::FontFaceDescriptors>(ExecState& state, JSValue value)
493 {
494     auto style = convertOptional<String>(state, propertyValue(state, value, "style"), "normal");
495     if (state.hadException())
496         return { };
497     auto weight = convertOptional<String>(state, propertyValue(state, value, "weight"), "normal");
498     if (state.hadException())
499         return { };
500     auto stretch = convertOptional<String>(state, propertyValue(state, value, "stretch"), "normal");
501     if (state.hadException())
502         return { };
503     auto unicodeRange = convertOptional<String>(state, propertyValue(state, value, "unicodeRange"), "U+0-10FFFF");
504     if (state.hadException())
505         return { };
506     auto variant = convertOptional<String>(state, propertyValue(state, value, "variant"), "normal");
507     if (state.hadException())
508         return { };
509     auto featureSettings = convertOptional<String>(state, propertyValue(state, value, "featureSettings"), "normal");
510     return { WTFMove(style), WTFMove(weight), WTFMove(stretch), WTFMove(unicodeRange), WTFMove(variant), WTFMove(featureSettings) };
511 }
512
513 // Functions
514
515 #if ENABLE(TEST_FEATURE)
516 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionEnabledAtRuntimeOperation(JSC::ExecState*);
517 #endif
518 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(JSC::ExecState*);
519 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(JSC::ExecState*);
520 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethod(JSC::ExecState*);
521 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethodWithArgs(JSC::ExecState*);
522 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethod(JSC::ExecState*);
523 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethodWithArgs(JSC::ExecState*);
524 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(JSC::ExecState*);
525 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(JSC::ExecState*);
526 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(JSC::ExecState*);
527 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(JSC::ExecState*);
528 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjInstanceFunctionUnforgeableMethod(JSC::ExecState*);
529 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithArgTreatingNullAsEmptyString(JSC::ExecState*);
530 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionNullableStringMethod(JSC::ExecState*);
531 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionNullableStringStaticMethod(JSC::ExecState*);
532 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionNullableStringSpecialMethod(JSC::ExecState*);
533 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithSequenceArg(JSC::ExecState*);
534 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodReturningSequence(JSC::ExecState*);
535 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithEnumArg(JSC::ExecState*);
536 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalEnumArgAndDefaultValue(JSC::ExecState*);
537 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(JSC::ExecState*);
538 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(JSC::ExecState*);
539 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOptionsObject(JSC::ExecState*);
540 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(JSC::ExecState*);
541 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithExceptionWithMessage(JSC::ExecState*);
542 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(JSC::ExecState*);
543 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(JSC::ExecState*);
544 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionPrivateMethod(JSC::ExecState*);
545 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(JSC::ExecState*);
546 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(JSC::ExecState*);
547 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(JSC::ExecState*);
548 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(JSC::ExecState*);
549 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(JSC::ExecState*);
550 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(JSC::ExecState*);
551 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContext(JSC::ExecState*);
552 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState(JSC::ExecState*);
553 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException(JSC::ExecState*);
554 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces(JSC::ExecState*);
555 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack(JSC::ExecState*);
556 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDocumentArgument(JSC::ExecState*);
557 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(JSC::ExecState*);
558 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArgAndDefaultValue(JSC::ExecState*);
559 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(JSC::ExecState*);
560 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(JSC::ExecState*);
561 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalString(JSC::ExecState*);
562 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicString(JSC::ExecState*);
563 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue(JSC::ExecState*);
564 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue(JSC::ExecState*);
565 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull(JSC::ExecState*);
566 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined(JSC::ExecState*);
567 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull(JSC::ExecState*);
568 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString(JSC::ExecState*);
569 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString(JSC::ExecState*);
570 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN(JSC::ExecState*);
571 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN(JSC::ExecState*);
572 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalSequence(JSC::ExecState*);
573 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalLongLong(JSC::ExecState*);
574 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalLongLongIsZero(JSC::ExecState*);
575 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLong(JSC::ExecState*);
576 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLongIsZero(JSC::ExecState*);
577 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArray(JSC::ExecState*);
578 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArrayIsEmpty(JSC::ExecState*);
579 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalBoolean(JSC::ExecState*);
580 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalBooleanIsFalse(JSC::ExecState*);
581 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAny(JSC::ExecState*);
582 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapper(JSC::ExecState*);
583 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapperIsNull(JSC::ExecState*);
584 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackArg(JSC::ExecState*);
585 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg(JSC::ExecState*);
586 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg(JSC::ExecState*);
587 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackFunctionArg(JSC::ExecState*);
588 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackFunctionArg(JSC::ExecState*);
589 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackFunctionAndOptionalArg(JSC::ExecState*);
590 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg(JSC::ExecState*);
591 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionStaticMethodWithCallbackArg(JSC::ExecState*);
592 #if ENABLE(Condition1)
593 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod1(JSC::ExecState*);
594 #endif
595 #if ENABLE(Condition1) && ENABLE(Condition2)
596 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod2(JSC::ExecState*);
597 #endif
598 #if ENABLE(Condition1) || ENABLE(Condition2)
599 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod3(JSC::ExecState*);
600 #endif
601 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(JSC::ExecState*);
602 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethodWithOptionalParameter(JSC::ExecState*);
603 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethod(JSC::ExecState*);
604 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethodWithOptional(JSC::ExecState*);
605 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethod2(JSC::ExecState*);
606 #if ENABLE(Condition1)
607 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionOverloadedMethod1(JSC::ExecState*);
608 #endif
609 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionClassMethodWithClamp(JSC::ExecState*);
610 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionClassMethodWithEnforceRange(JSC::ExecState*);
611 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence(JSC::ExecState*);
612 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStringArrayFunction(JSC::ExecState*);
613 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionDomStringListFunction(JSC::ExecState*);
614 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence(JSC::ExecState*);
615 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence2(JSC::ExecState*);
616 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionGetSVGDocument(JSC::ExecState*);
617 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert1(JSC::ExecState*);
618 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert2(JSC::ExecState*);
619 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert3(JSC::ExecState*);
620 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert4(JSC::ExecState*);
621 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMutablePointFunction(JSC::ExecState*);
622 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionImmutablePointFunction(JSC::ExecState*);
623 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOrange(JSC::ExecState*);
624 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunction(JSC::ExecState*);
625 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithSequence(JSC::ExecState*);
626 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithArray(JSC::ExecState*);
627 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicStringMethod(JSC::ExecState*);
628 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicDoubleMethod(JSC::ExecState*);
629 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicNodeMethod(JSC::ExecState*);
630 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAny(JSC::ExecState*);
631 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(JSC::ExecState*);
632 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(JSC::ExecState*);
633 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(JSC::ExecState*);
634 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(JSC::ExecState*);
635 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunction(JSC::ExecState*);
636 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(JSC::ExecState*);
637 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(JSC::ExecState*);
638 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNeedsLifecycleProcessingStack(JSC::ExecState*);
639 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAttachShadowRoot(JSC::ExecState*);
640 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSymbolIterator(JSC::ExecState*);
641 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionEntries(JSC::ExecState*);
642 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionKeys(JSC::ExecState*);
643 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionValues(JSC::ExecState*);
644 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionForEach(JSC::ExecState*);
645
646 // Attributes
647
648 JSC::EncodedJSValue jsTestObjReadOnlyLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
649 JSC::EncodedJSValue jsTestObjReadOnlyStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
650 JSC::EncodedJSValue jsTestObjReadOnlyTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
651 JSC::EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
652 JSC::EncodedJSValue jsTestObjConstructorStaticStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
653 bool setJSTestObjConstructorStaticStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
654 JSC::EncodedJSValue jsTestObjConstructorTestSubObj(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
655 JSC::EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
656 bool setJSTestObjTestSubObjEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
657 JSC::EncodedJSValue jsTestObjEnumAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
658 bool setJSTestObjEnumAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
659 JSC::EncodedJSValue jsTestObjByteAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
660 bool setJSTestObjByteAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
661 JSC::EncodedJSValue jsTestObjOctetAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
662 bool setJSTestObjOctetAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
663 JSC::EncodedJSValue jsTestObjShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
664 bool setJSTestObjShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
665 JSC::EncodedJSValue jsTestObjClampedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
666 bool setJSTestObjClampedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
667 JSC::EncodedJSValue jsTestObjEnforceRangeShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
668 bool setJSTestObjEnforceRangeShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
669 JSC::EncodedJSValue jsTestObjUnsignedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
670 bool setJSTestObjUnsignedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
671 JSC::EncodedJSValue jsTestObjLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
672 bool setJSTestObjLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
673 JSC::EncodedJSValue jsTestObjLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
674 bool setJSTestObjLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
675 JSC::EncodedJSValue jsTestObjUnsignedLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
676 bool setJSTestObjUnsignedLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
677 JSC::EncodedJSValue jsTestObjStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
678 bool setJSTestObjStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
679 JSC::EncodedJSValue jsTestObjTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
680 bool setJSTestObjTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
681 JSC::EncodedJSValue jsTestObjTestNullableObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
682 bool setJSTestObjTestNullableObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
683 JSC::EncodedJSValue jsTestObjLenientTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
684 bool setJSTestObjLenientTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
685 JSC::EncodedJSValue jsTestObjUnforgeableAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
686 JSC::EncodedJSValue jsTestObjStringAttrTreatingNullAsEmptyString(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
687 bool setJSTestObjStringAttrTreatingNullAsEmptyString(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
688 JSC::EncodedJSValue jsTestObjXMLObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
689 bool setJSTestObjXMLObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
690 JSC::EncodedJSValue jsTestObjCreate(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
691 bool setJSTestObjCreate(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
692 JSC::EncodedJSValue jsTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
693 bool setJSTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
694 JSC::EncodedJSValue jsTestObjReflectedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
695 bool setJSTestObjReflectedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
696 JSC::EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
697 bool setJSTestObjReflectedUnsignedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
698 JSC::EncodedJSValue jsTestObjReflectedBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
699 bool setJSTestObjReflectedBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
700 JSC::EncodedJSValue jsTestObjReflectedURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
701 bool setJSTestObjReflectedURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
702 JSC::EncodedJSValue jsTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
703 bool setJSTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
704 JSC::EncodedJSValue jsTestObjReflectedCustomIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
705 bool setJSTestObjReflectedCustomIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
706 JSC::EncodedJSValue jsTestObjReflectedCustomBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
707 bool setJSTestObjReflectedCustomBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
708 JSC::EncodedJSValue jsTestObjReflectedCustomURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
709 bool setJSTestObjReflectedCustomURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
710 #if ENABLE(TEST_FEATURE)
711 JSC::EncodedJSValue jsTestObjEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
712 bool setJSTestObjEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
713 #endif
714 JSC::EncodedJSValue jsTestObjTypedArrayAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
715 bool setJSTestObjTypedArrayAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
716 JSC::EncodedJSValue jsTestObjAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
717 bool setJSTestObjAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
718 JSC::EncodedJSValue jsTestObjAttrWithGetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
719 bool setJSTestObjAttrWithGetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
720 JSC::EncodedJSValue jsTestObjAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
721 bool setJSTestObjAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
722 JSC::EncodedJSValue jsTestObjAttrWithSetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
723 bool setJSTestObjAttrWithSetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
724 JSC::EncodedJSValue jsTestObjStringAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
725 bool setJSTestObjStringAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
726 JSC::EncodedJSValue jsTestObjStringAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
727 bool setJSTestObjStringAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
728 JSC::EncodedJSValue jsTestObjStrictTypeCheckingAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
729 bool setJSTestObjStrictTypeCheckingAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
730 JSC::EncodedJSValue jsTestObjCustomAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
731 bool setJSTestObjCustomAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
732 JSC::EncodedJSValue jsTestObjOnfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
733 bool setJSTestObjOnfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
734 JSC::EncodedJSValue jsTestObjOnwebkitfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
735 bool setJSTestObjOnwebkitfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
736 JSC::EncodedJSValue jsTestObjWithScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
737 bool setJSTestObjWithScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
738 JSC::EncodedJSValue jsTestObjWithCallWithAndSetterCallWithAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
739 bool setJSTestObjWithCallWithAndSetterCallWithAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
740 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
741 bool setJSTestObjWithScriptExecutionContextAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
742 JSC::EncodedJSValue jsTestObjWithScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
743 bool setJSTestObjWithScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
744 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
745 bool setJSTestObjWithScriptExecutionContextAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
746 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
747 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
748 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
749 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
750 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
751 bool setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
752 JSC::EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
753 bool setJSTestObjWithScriptArgumentsAndCallStackAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
754 #if ENABLE(Condition1)
755 JSC::EncodedJSValue jsTestObjConditionalAttr1(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
756 bool setJSTestObjConditionalAttr1(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
757 #endif
758 #if ENABLE(Condition1) && ENABLE(Condition2)
759 JSC::EncodedJSValue jsTestObjConditionalAttr2(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
760 bool setJSTestObjConditionalAttr2(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
761 #endif
762 #if ENABLE(Condition1) || ENABLE(Condition2)
763 JSC::EncodedJSValue jsTestObjConditionalAttr3(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
764 bool setJSTestObjConditionalAttr3(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
765 #endif
766 #if ENABLE(Condition1)
767 JSC::EncodedJSValue jsTestObjConditionalAttr4Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
768 bool setJSTestObjConditionalAttr4Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
769 #endif
770 #if ENABLE(Condition1) && ENABLE(Condition2)
771 JSC::EncodedJSValue jsTestObjConditionalAttr5Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
772 bool setJSTestObjConditionalAttr5Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
773 #endif
774 #if ENABLE(Condition1) || ENABLE(Condition2)
775 JSC::EncodedJSValue jsTestObjConditionalAttr6Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
776 bool setJSTestObjConditionalAttr6Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
777 #endif
778 JSC::EncodedJSValue jsTestObjCachedAttribute1(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
779 JSC::EncodedJSValue jsTestObjCachedAttribute2(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
780 JSC::EncodedJSValue jsTestObjAnyAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
781 bool setJSTestObjAnyAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
782 JSC::EncodedJSValue jsTestObjContentDocument(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
783 JSC::EncodedJSValue jsTestObjMutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
784 bool setJSTestObjMutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
785 JSC::EncodedJSValue jsTestObjImmutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
786 bool setJSTestObjImmutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
787 JSC::EncodedJSValue jsTestObjStrawberry(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
788 bool setJSTestObjStrawberry(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
789 JSC::EncodedJSValue jsTestObjStrictFloat(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
790 bool setJSTestObjStrictFloat(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
791 JSC::EncodedJSValue jsTestObjDescription(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
792 JSC::EncodedJSValue jsTestObjId(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
793 bool setJSTestObjId(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
794 JSC::EncodedJSValue jsTestObjHash(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
795 JSC::EncodedJSValue jsTestObjReplaceableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
796 bool setJSTestObjReplaceableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
797 JSC::EncodedJSValue jsTestObjNullableDoubleAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
798 JSC::EncodedJSValue jsTestObjNullableLongAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
799 JSC::EncodedJSValue jsTestObjNullableBooleanAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
800 JSC::EncodedJSValue jsTestObjNullableStringAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
801 JSC::EncodedJSValue jsTestObjNullableLongSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
802 bool setJSTestObjNullableLongSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
803 JSC::EncodedJSValue jsTestObjNullableStringSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
804 bool setJSTestObjNullableStringSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
805 JSC::EncodedJSValue jsTestObjNullableStringValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
806 bool setJSTestObjNullableStringValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
807 JSC::EncodedJSValue jsTestObjAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
808 JSC::EncodedJSValue jsTestObjAttributeWithReservedEnumType(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
809 bool setJSTestObjAttributeWithReservedEnumType(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
810 JSC::EncodedJSValue jsTestObjPutForwardsAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
811 bool setJSTestObjPutForwardsAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
812 JSC::EncodedJSValue jsTestObjPutForwardsNullableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
813 bool setJSTestObjPutForwardsNullableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
814 JSC::EncodedJSValue jsTestObjConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
815 bool setJSTestObjConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
816
817 class JSTestObjPrototype : public JSC::JSNonFinalObject {
818 public:
819     typedef JSC::JSNonFinalObject Base;
820     static JSTestObjPrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
821     {
822         JSTestObjPrototype* ptr = new (NotNull, JSC::allocateCell<JSTestObjPrototype>(vm.heap)) JSTestObjPrototype(vm, globalObject, structure);
823         ptr->finishCreation(vm);
824         return ptr;
825     }
826
827     DECLARE_INFO;
828     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
829     {
830         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
831     }
832
833 private:
834     JSTestObjPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
835         : JSC::JSNonFinalObject(vm, structure)
836     {
837     }
838
839     void finishCreation(JSC::VM&);
840 };
841
842 typedef JSDOMConstructor<JSTestObj> JSTestObjConstructor;
843
844 /* Hash table */
845
846 static const struct CompactHashIndex JSTestObjTableIndex[17] = {
847     { -1, -1 },
848     { -1, -1 },
849     { 5, -1 },
850     { -1, -1 },
851     { -1, -1 },
852     { -1, -1 },
853     { 4, -1 },
854     { -1, -1 },
855     { 1, -1 },
856     { 2, -1 },
857     { 0, 16 },
858     { -1, -1 },
859     { -1, -1 },
860     { -1, -1 },
861     { -1, -1 },
862     { -1, -1 },
863     { 3, -1 },
864 };
865
866
867 static const HashTableValue JSTestObjTableValues[] =
868 {
869     { "TestSubObjEnabledBySetting", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestSubObjEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestSubObjEnabledBySettingConstructor) } },
870     { "unforgeableAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnforgeableAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
871 #if ENABLE(Condition1)
872     { "conditionalAttr4", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr4Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr4Constructor) } },
873 #else
874     { 0, 0, NoIntrinsic, { 0, 0 } },
875 #endif
876 #if ENABLE(Condition1) && ENABLE(Condition2)
877     { "conditionalAttr5", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr5Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr5Constructor) } },
878 #else
879     { 0, 0, NoIntrinsic, { 0, 0 } },
880 #endif
881 #if ENABLE(Condition1) || ENABLE(Condition2)
882     { "conditionalAttr6", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr6Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr6Constructor) } },
883 #else
884     { 0, 0, NoIntrinsic, { 0, 0 } },
885 #endif
886     { "unforgeableMethod", DontDelete | ReadOnly | JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjInstanceFunctionUnforgeableMethod), (intptr_t) (0) } },
887 };
888
889 static const HashTable JSTestObjTable = { 6, 15, true, JSTestObjTableValues, JSTestObjTableIndex };
890 /* Hash table for constructor */
891
892 static const HashTableValue JSTestObjConstructorTableValues[] =
893 {
894 #if ENABLE(Condition1)
895     { "CONDITIONAL_CONST", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
896 #else
897     { 0, 0, NoIntrinsic, { 0, 0 } },
898 #endif
899     { "CONST_VALUE_0", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
900     { "CONST_VALUE_1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
901     { "CONST_VALUE_2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
902     { "CONST_VALUE_4", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(4) } },
903     { "CONST_VALUE_8", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(8) } },
904     { "CONST_VALUE_9", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(-1) } },
905     { "CONST_VALUE_11", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0xffffffff) } },
906     { "CONST_VALUE_12", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x01) } },
907     { "CONST_VALUE_13", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0X20) } },
908     { "CONST_VALUE_14", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x1abc) } },
909     { "CONST_JAVASCRIPT", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(15) } },
910     { "readonly", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
911     { "staticReadOnlyLongAttr", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
912     { "staticStringAttr", DontDelete, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructorStaticStringAttr) } },
913     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
914     { "nullableStringStaticMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionNullableStringStaticMethod), (intptr_t) (0) } },
915     { "staticMethodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg), (intptr_t) (0) } },
916     { "staticMethodWithCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackArg), (intptr_t) (1) } },
917     { "classMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod), (intptr_t) (0) } },
918     { "classMethodWithOptional", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethodWithOptional), (intptr_t) (0) } },
919     { "classMethod2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod2), (intptr_t) (1) } },
920 #if ENABLE(Condition1)
921     { "overloadedMethod1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionOverloadedMethod1), (intptr_t) (1) } },
922 #else
923     { 0, 0, NoIntrinsic, { 0, 0 } },
924 #endif
925     { "testStaticPromiseFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionTestStaticPromiseFunction), (intptr_t) (0) } },
926     { "testStaticPromiseFunctionWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException), (intptr_t) (0) } },
927 };
928
929 #if ENABLE(Condition1)
930 static_assert(TestObj::CONDITIONAL_CONST == 0, "CONDITIONAL_CONST in TestObj does not match value from IDL");
931 #endif
932 static_assert(TestObj::CONST_VALUE_0 == 0, "CONST_VALUE_0 in TestObj does not match value from IDL");
933 static_assert(TestObj::CONST_VALUE_1 == 1, "CONST_VALUE_1 in TestObj does not match value from IDL");
934 static_assert(TestObj::CONST_VALUE_2 == 2, "CONST_VALUE_2 in TestObj does not match value from IDL");
935 static_assert(TestObj::CONST_VALUE_4 == 4, "CONST_VALUE_4 in TestObj does not match value from IDL");
936 static_assert(TestObj::CONST_VALUE_8 == 8, "CONST_VALUE_8 in TestObj does not match value from IDL");
937 static_assert(TestObj::CONST_VALUE_9 == -1, "CONST_VALUE_9 in TestObj does not match value from IDL");
938 static_assert(TestObj::CONST_VALUE_11 == 0xffffffff, "CONST_VALUE_11 in TestObj does not match value from IDL");
939 static_assert(TestObj::CONST_VALUE_12 == 0x01, "CONST_VALUE_12 in TestObj does not match value from IDL");
940 static_assert(TestObj::CONST_VALUE_13 == 0X20, "CONST_VALUE_13 in TestObj does not match value from IDL");
941 static_assert(TestObj::CONST_VALUE_14 == 0x1abc, "CONST_VALUE_14 in TestObj does not match value from IDL");
942 static_assert(TestObj::CONST_IMPL == 15, "CONST_IMPL in TestObj does not match value from IDL");
943 static_assert(TestObj::readonly == 0, "readonly in TestObj does not match value from IDL");
944
945 template<> EncodedJSValue JSC_HOST_CALL JSTestObjConstructor::construct(ExecState* state)
946 {
947     auto* castedThis = jsCast<JSTestObjConstructor*>(state->callee());
948     if (UNLIKELY(state->argumentCount() < 2))
949         return throwVMError(state, createNotEnoughArgumentsError(state));
950     if (UNLIKELY(!state->argument(0).isObject()))
951         return throwArgumentMustBeFunctionError(*state, 0, "testCallback", "TestObj", nullptr);
952     RefPtr<TestCallback> testCallback = JSTestCallback::create(asObject(state->uncheckedArgument(0)), castedThis->globalObject());
953     if (UNLIKELY(!state->argument(1).isFunction()))
954         return throwArgumentMustBeFunctionError(*state, 1, "testCallbackFunction", "TestObj", nullptr);
955     RefPtr<TestCallbackFunction> testCallbackFunction = JSTestCallbackFunction::create(asObject(state->uncheckedArgument(1)), castedThis->globalObject());
956     RefPtr<TestObj> object = TestObj::create(*testCallback, *testCallbackFunction);
957     return JSValue::encode(asObject(toJS(state, castedThis->globalObject(), object.get())));
958 }
959
960 template<> JSValue JSTestObjConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
961 {
962     UNUSED_PARAM(vm);
963     return globalObject.functionPrototype();
964 }
965
966 template<> void JSTestObjConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
967 {
968     putDirect(vm, vm.propertyNames->prototype, JSTestObj::prototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
969     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestObject"))), ReadOnly | DontEnum);
970     putDirect(vm, vm.propertyNames->length, jsNumber(2), ReadOnly | DontEnum);
971     reifyStaticProperties(vm, JSTestObjConstructorTableValues, *this);
972 }
973
974 template<> const ClassInfo JSTestObjConstructor::s_info = { "TestObject", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestObjConstructor) };
975
976 /* Hash table for prototype */
977
978 static const HashTableValue JSTestObjPrototypeTableValues[] =
979 {
980     { "constructor", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructor) } },
981     { "readOnlyLongAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
982     { "readOnlyStringAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
983     { "readOnlyTestObjAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
984     { "enumAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnumAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnumAttr) } },
985     { "byteAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjByteAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjByteAttr) } },
986     { "octetAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOctetAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOctetAttr) } },
987     { "shortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjShortAttr) } },
988     { "clampedShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjClampedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjClampedShortAttr) } },
989     { "enforceRangeShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnforceRangeShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnforceRangeShortAttr) } },
990     { "unsignedShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedShortAttr) } },
991     { "longAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongAttr) } },
992     { "longLongAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongLongAttr) } },
993     { "unsignedLongLongAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedLongLongAttr) } },
994     { "stringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttr) } },
995     { "testObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestObjAttr) } },
996     { "testNullableObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestNullableObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestNullableObjAttr) } },
997     { "lenientTestObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLenientTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLenientTestObjAttr) } },
998     { "stringAttrTreatingNullAsEmptyString", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrTreatingNullAsEmptyString), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrTreatingNullAsEmptyString) } },
999     { "XMLObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjXMLObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjXMLObjAttr) } },
1000     { "create", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCreate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCreate) } },
1001     { "reflectedStringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) } },
1002     { "reflectedIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedIntegralAttr) } },
1003     { "reflectedUnsignedIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedUnsignedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedUnsignedIntegralAttr) } },
1004     { "reflectedBooleanAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedBooleanAttr) } },
1005     { "reflectedURLAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedURLAttr) } },
1006     { "reflectedStringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) } },
1007     { "reflectedCustomIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomIntegralAttr) } },
1008     { "reflectedCustomBooleanAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomBooleanAttr) } },
1009     { "reflectedCustomURLAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomURLAttr) } },
1010 #if ENABLE(TEST_FEATURE)
1011     { "enabledAtRuntimeAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnabledAtRuntimeAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnabledAtRuntimeAttribute) } },
1012 #else
1013     { 0, 0, NoIntrinsic, { 0, 0 } },
1014 #endif
1015     { "typedArrayAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTypedArrayAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTypedArrayAttr) } },
1016     { "attrWithGetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterException) } },
1017     { "attrWithGetterExceptionWithMessage", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterExceptionWithMessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterExceptionWithMessage) } },
1018     { "attrWithSetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterException) } },
1019     { "attrWithSetterExceptionWithMessage", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterExceptionWithMessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterExceptionWithMessage) } },
1020     { "stringAttrWithGetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithGetterException) } },
1021     { "stringAttrWithSetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithSetterException) } },
1022     { "strictTypeCheckingAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictTypeCheckingAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictTypeCheckingAttribute) } },
1023     { "customAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCustomAttr) } },
1024 #if ENABLE(Condition4)
1025     { "jsBuiltinAttribute", Accessor | Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinAttributeCodeGenerator), (intptr_t) (setTestObjJsBuiltinAttributeCodeGenerator) } },
1026 #else
1027     { 0, 0, NoIntrinsic, { 0, 0 } },
1028 #endif
1029 #if ENABLE(Condition4)
1030     { "jsBuiltinReadOnlyAttribute", ReadOnly | Accessor | Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinReadOnlyAttributeCodeGenerator), (intptr_t) (0) } },
1031 #else
1032     { 0, 0, NoIntrinsic, { 0, 0 } },
1033 #endif
1034     { "onfoo", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOnfoo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOnfoo) } },
1035     { "onwebkitfoo", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOnwebkitfoo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOnwebkitfoo) } },
1036     { "withScriptStateAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttribute) } },
1037     { "withCallWithAndSetterCallWithAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithCallWithAndSetterCallWithAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithCallWithAndSetterCallWithAttribute) } },
1038     { "withScriptExecutionContextAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttribute) } },
1039     { "withScriptStateAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttributeRaises) } },
1040     { "withScriptExecutionContextAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttributeRaises) } },
1041     { "withScriptExecutionContextAndScriptStateAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttribute) } },
1042     { "withScriptExecutionContextAndScriptStateAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises) } },
1043     { "withScriptExecutionContextAndScriptStateWithSpacesAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute) } },
1044     { "withScriptArgumentsAndCallStackAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) } },
1045 #if ENABLE(Condition1)
1046     { "conditionalAttr1", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) } },
1047 #else
1048     { 0, 0, NoIntrinsic, { 0, 0 } },
1049 #endif
1050 #if ENABLE(Condition1) && ENABLE(Condition2)
1051     { "conditionalAttr2", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) } },
1052 #else
1053     { 0, 0, NoIntrinsic, { 0, 0 } },
1054 #endif
1055 #if ENABLE(Condition1) || ENABLE(Condition2)
1056     { "conditionalAttr3", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) } },
1057 #else
1058     { 0, 0, NoIntrinsic, { 0, 0 } },
1059 #endif
1060     { "cachedAttribute1", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1061     { "cachedAttribute2", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1062     { "anyAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAnyAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAnyAttribute) } },
1063     { "contentDocument", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjContentDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1064     { "mutablePoint", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjMutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjMutablePoint) } },
1065     { "immutablePoint", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjImmutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjImmutablePoint) } },
1066     { "strawberry", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrawberry), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrawberry) } },
1067     { "strictFloat", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictFloat), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictFloat) } },
1068     { "description", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDescription), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1069     { "id", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjId), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjId) } },
1070     { "hash", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjHash), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1071     { "replaceableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReplaceableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReplaceableAttribute) } },
1072     { "nullableDoubleAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableDoubleAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1073     { "nullableLongAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1074     { "nullableBooleanAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableBooleanAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1075     { "nullableStringAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1076     { "nullableLongSettableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableLongSettableAttribute) } },
1077     { "nullableStringSettableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringSettableAttribute) } },
1078     { "nullableStringValue", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringValue) } },
1079     { "attribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1080     { "attributeWithReservedEnumType", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) } },
1081     { "putForwardsAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsAttribute) } },
1082     { "putForwardsNullableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsNullableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsNullableAttribute) } },
1083 #if ENABLE(TEST_FEATURE)
1084     { "enabledAtRuntimeOperation", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionEnabledAtRuntimeOperation), (intptr_t) (1) } },
1085 #else
1086     { 0, 0, NoIntrinsic, { 0, 0 } },
1087 #endif
1088     { "voidMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t) (0) } },
1089     { "voidMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t) (3) } },
1090     { "byteMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethod), (intptr_t) (0) } },
1091     { "byteMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethodWithArgs), (intptr_t) (3) } },
1092     { "octetMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethod), (intptr_t) (0) } },
1093     { "octetMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethodWithArgs), (intptr_t) (3) } },
1094     { "longMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethod), (intptr_t) (0) } },
1095     { "longMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethodWithArgs), (intptr_t) (3) } },
1096     { "objMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethod), (intptr_t) (0) } },
1097     { "objMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethodWithArgs), (intptr_t) (3) } },
1098     { "methodWithArgTreatingNullAsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithArgTreatingNullAsEmptyString), (intptr_t) (1) } },
1099     { "nullableStringMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionNullableStringMethod), (intptr_t) (0) } },
1100     { "nullableStringSpecialMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionNullableStringSpecialMethod), (intptr_t) (1) } },
1101     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) } },
1102     { "methodReturningSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodReturningSequence), (intptr_t) (1) } },
1103     { "methodWithEnumArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithEnumArg), (intptr_t) (1) } },
1104     { "methodWithOptionalEnumArgAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalEnumArgAndDefaultValue), (intptr_t) (0) } },
1105     { "methodThatRequiresAllArgsAndThrows", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows), (intptr_t) (2) } },
1106     { "serializedValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionSerializedValue), (intptr_t) (1) } },
1107     { "optionsObject", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOptionsObject), (intptr_t) (1) } },
1108     { "methodWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithException), (intptr_t) (0) } },
1109     { "methodWithExceptionWithMessage", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithExceptionWithMessage), (intptr_t) (0) } },
1110     { "customMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethod), (intptr_t) (0) } },
1111     { "customMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethodWithArgs), (intptr_t) (3) } },
1112 #if ENABLE(Condition3)
1113     { "jsBuiltinMethod", JSC::Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinMethodCodeGenerator), (intptr_t) (0) } },
1114 #else
1115     { 0, 0, NoIntrinsic, { 0, 0 } },
1116 #endif
1117 #if ENABLE(Condition3)
1118     { "jsBuiltinMethodWithArgs", JSC::Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinMethodWithArgsCodeGenerator), (intptr_t) (3) } },
1119 #else
1120     { 0, 0, NoIntrinsic, { 0, 0 } },
1121 #endif
1122     { "addEventListener", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAddEventListener), (intptr_t) (2) } },
1123     { "removeEventListener", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionRemoveEventListener), (intptr_t) (2) } },
1124     { "withScriptStateVoid", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoid), (intptr_t) (0) } },
1125     { "withScriptStateObj", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObj), (intptr_t) (0) } },
1126     { "withScriptStateVoidException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoidException), (intptr_t) (0) } },
1127     { "withScriptStateObjException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObjException), (intptr_t) (0) } },
1128     { "withScriptExecutionContext", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContext), (intptr_t) (0) } },
1129     { "withScriptExecutionContextAndScriptState", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState), (intptr_t) (0) } },
1130     { "withScriptExecutionContextAndScriptStateObjException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException), (intptr_t) (0) } },
1131     { "withScriptExecutionContextAndScriptStateWithSpaces", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces), (intptr_t) (0) } },
1132     { "withScriptArgumentsAndCallStack", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack), (intptr_t) (0) } },
1133     { "withDocumentArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithDocumentArgument), (intptr_t) (0) } },
1134     { "methodWithOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArg), (intptr_t) (0) } },
1135     { "methodWithOptionalArgAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArgAndDefaultValue), (intptr_t) (0) } },
1136     { "methodWithNonOptionalArgAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg), (intptr_t) (1) } },
1137     { "methodWithNonOptionalArgAndTwoOptionalArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs), (intptr_t) (1) } },
1138     { "methodWithOptionalString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalString), (intptr_t) (0) } },
1139     { "methodWithOptionalAtomicString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicString), (intptr_t) (0) } },
1140     { "methodWithOptionalStringAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue), (intptr_t) (0) } },
1141     { "methodWithOptionalAtomicStringAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue), (intptr_t) (0) } },
1142     { "methodWithOptionalStringIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull), (intptr_t) (0) } },
1143     { "methodWithOptionalStringIsUndefined", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined), (intptr_t) (0) } },
1144     { "methodWithOptionalAtomicStringIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull), (intptr_t) (0) } },
1145     { "methodWithOptionalStringIsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString), (intptr_t) (0) } },
1146     { "methodWithOptionalAtomicStringIsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString), (intptr_t) (0) } },
1147     { "methodWithOptionalDoubleIsNaN", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN), (intptr_t) (0) } },
1148     { "methodWithOptionalFloatIsNaN", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN), (intptr_t) (0) } },
1149     { "methodWithOptionalSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalSequence), (intptr_t) (0) } },
1150     { "methodWithOptionalLongLong", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalLongLong), (intptr_t) (0) } },
1151     { "methodWithOptionalLongLongIsZero", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalLongLongIsZero), (intptr_t) (0) } },
1152     { "methodWithOptionalUnsignedLongLong", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLong), (intptr_t) (0) } },
1153     { "methodWithOptionalUnsignedLongLongIsZero", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLongIsZero), (intptr_t) (0) } },
1154     { "methodWithOptionalArray", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArray), (intptr_t) (0) } },
1155     { "methodWithOptionalArrayIsEmpty", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArrayIsEmpty), (intptr_t) (0) } },
1156     { "methodWithOptionalBoolean", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalBoolean), (intptr_t) (0) } },
1157     { "methodWithOptionalBooleanIsFalse", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalBooleanIsFalse), (intptr_t) (0) } },
1158     { "methodWithOptionalAny", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAny), (intptr_t) (0) } },
1159     { "methodWithOptionalNullableWrapper", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapper), (intptr_t) (0) } },
1160     { "methodWithOptionalNullableWrapperIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapperIsNull), (intptr_t) (0) } },
1161     { "methodWithCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackArg), (intptr_t) (1) } },
1162     { "methodWithNonCallbackArgAndCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg), (intptr_t) (2) } },
1163     { "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) } },
1164     { "methodWithCallbackFunctionArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackFunctionArg), (intptr_t) (1) } },
1165     { "methodWithNonCallbackArgAndCallbackFunctionArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackFunctionArg), (intptr_t) (2) } },
1166     { "methodWithCallbackFunctionAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackFunctionAndOptionalArg), (intptr_t) (0) } },
1167 #if ENABLE(Condition1)
1168     { "conditionalMethod1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) } },
1169 #else
1170     { 0, 0, NoIntrinsic, { 0, 0 } },
1171 #endif
1172 #if ENABLE(Condition1) && ENABLE(Condition2)
1173     { "conditionalMethod2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) } },
1174 #else
1175     { 0, 0, NoIntrinsic, { 0, 0 } },
1176 #endif
1177 #if ENABLE(Condition1) || ENABLE(Condition2)
1178     { "conditionalMethod3", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) } },
1179 #else
1180     { 0, 0, NoIntrinsic, { 0, 0 } },
1181 #endif
1182     { "overloadedMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) } },
1183     { "overloadedMethodWithOptionalParameter", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethodWithOptionalParameter), (intptr_t) (1) } },
1184     { "classMethodWithClamp", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) } },
1185     { "classMethodWithEnforceRange", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithEnforceRange), (intptr_t) (2) } },
1186     { "methodWithUnsignedLongSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence), (intptr_t) (1) } },
1187     { "stringArrayFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStringArrayFunction), (intptr_t) (1) } },
1188     { "domStringListFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionDomStringListFunction), (intptr_t) (1) } },
1189     { "methodWithAndWithoutNullableSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence), (intptr_t) (2) } },
1190     { "methodWithAndWithoutNullableSequence2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence2), (intptr_t) (2) } },
1191     { "getSVGDocument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionGetSVGDocument), (intptr_t) (0) } },
1192     { "convert1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert1), (intptr_t) (1) } },
1193     { "convert2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert2), (intptr_t) (1) } },
1194     { "convert3", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert3), (intptr_t) (1) } },
1195     { "convert4", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert4), (intptr_t) (1) } },
1196     { "mutablePointFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMutablePointFunction), (intptr_t) (0) } },
1197     { "immutablePointFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionImmutablePointFunction), (intptr_t) (0) } },
1198     { "orange", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOrange), (intptr_t) (0) } },
1199     { "strictFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunction), (intptr_t) (3) } },
1200     { "strictFunctionWithSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithSequence), (intptr_t) (2) } },
1201     { "strictFunctionWithArray", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithArray), (intptr_t) (2) } },
1202     { "variadicStringMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicStringMethod), (intptr_t) (1) } },
1203     { "variadicDoubleMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (1) } },
1204     { "variadicNodeMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (1) } },
1205     { "any", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) } },
1206     { "testPromiseFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunction), (intptr_t) (0) } },
1207     { "testPromiseFunctionWithFloatArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument), (intptr_t) (1) } },
1208     { "testPromiseFunctionWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithException), (intptr_t) (0) } },
1209     { "testPromiseFunctionWithOptionalIntArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument), (intptr_t) (0) } },
1210     { "testPromiseOverloadedFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseOverloadedFunction), (intptr_t) (1) } },
1211     { "methodWithNeedsLifecycleProcessingStack", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNeedsLifecycleProcessingStack), (intptr_t) (0) } },
1212     { "attachShadowRoot", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAttachShadowRoot), (intptr_t) (1) } },
1213     { "entries", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionEntries), (intptr_t) (0) } },
1214     { "keys", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionKeys), (intptr_t) (0) } },
1215     { "values", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionValues), (intptr_t) (0) } },
1216     { "forEach", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionForEach), (intptr_t) (1) } },
1217 #if ENABLE(Condition1)
1218     { "CONDITIONAL_CONST", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
1219 #else
1220     { 0, 0, NoIntrinsic, { 0, 0 } },
1221 #endif
1222     { "CONST_VALUE_0", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
1223     { "CONST_VALUE_1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
1224     { "CONST_VALUE_2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
1225     { "CONST_VALUE_4", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(4) } },
1226     { "CONST_VALUE_8", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(8) } },
1227     { "CONST_VALUE_9", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(-1) } },
1228     { "CONST_VALUE_11", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0xffffffff) } },
1229     { "CONST_VALUE_12", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x01) } },
1230     { "CONST_VALUE_13", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0X20) } },
1231     { "CONST_VALUE_14", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x1abc) } },
1232     { "CONST_JAVASCRIPT", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(15) } },
1233     { "readonly", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
1234 };
1235
1236 const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
1237
1238 void JSTestObjPrototype::finishCreation(VM& vm)
1239 {
1240     Base::finishCreation(vm);
1241     reifyStaticProperties(vm, JSTestObjPrototypeTableValues, *this);
1242 #if ENABLE(TEST_FEATURE)
1243     if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
1244         Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>("enabledAtRuntimeOperation"), strlen("enabledAtRuntimeOperation"));
1245         removeDirect(vm, propertyName);
1246     }
1247 #endif
1248 #if ENABLE(TEST_FEATURE)
1249     if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
1250         Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>("enabledAtRuntimeAttribute"), strlen("enabledAtRuntimeAttribute"));
1251         removeDirect(vm, propertyName);
1252     }
1253 #endif
1254     JSVMClientData& clientData = *static_cast<JSVMClientData*>(vm.clientData);
1255     putDirect(vm, clientData.builtinNames().privateMethodPrivateName(), JSFunction::create(vm, globalObject(), 0, String(), jsTestObjPrototypeFunctionPrivateMethod), ReadOnly | DontEnum);
1256     putDirect(vm, vm.propertyNames->iteratorSymbol, JSFunction::create(vm, globalObject(), 0, ASCIILiteral("[Symbol.Iterator]"), jsTestObjPrototypeFunctionSymbolIterator), ReadOnly | DontEnum);
1257 }
1258
1259 const ClassInfo JSTestObj::s_info = { "TestObject", &Base::s_info, &JSTestObjTable, CREATE_METHOD_TABLE(JSTestObj) };
1260
1261 JSTestObj::JSTestObj(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestObj>&& impl)
1262     : JSDOMWrapper<TestObj>(structure, globalObject, WTFMove(impl))
1263 {
1264 }
1265
1266 JSObject* JSTestObj::createPrototype(VM& vm, JSGlobalObject* globalObject)
1267 {
1268     return JSTestObjPrototype::create(vm, globalObject, JSTestObjPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
1269 }
1270
1271 JSObject* JSTestObj::prototype(VM& vm, JSGlobalObject* globalObject)
1272 {
1273     return getDOMPrototype<JSTestObj>(vm, globalObject);
1274 }
1275
1276 void JSTestObj::destroy(JSC::JSCell* cell)
1277 {
1278     JSTestObj* thisObject = static_cast<JSTestObj*>(cell);
1279     thisObject->JSTestObj::~JSTestObj();
1280 }
1281
1282 bool JSTestObj::getOwnPropertySlot(JSObject* object, ExecState* state, PropertyName propertyName, PropertySlot& slot)
1283 {
1284     auto* thisObject = jsCast<JSTestObj*>(object);
1285     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
1286     Optional<uint32_t> optionalIndex = parseIndex(propertyName);
1287     if (optionalIndex) {
1288         unsigned index = optionalIndex.value();
1289         unsigned attributes = DontDelete | ReadOnly;
1290         slot.setValue(thisObject, attributes, jsStringOrUndefined(state, thisObject->wrapped().item(index)));
1291         return true;
1292     }
1293     if (getStaticPropertySlot<JSTestObj, Base>(state, JSTestObjTable, thisObject, propertyName, slot))
1294         return true;
1295     return false;
1296 }
1297
1298 bool JSTestObj::getOwnPropertySlotByIndex(JSObject* object, ExecState* state, unsigned index, PropertySlot& slot)
1299 {
1300     auto* thisObject = jsCast<JSTestObj*>(object);
1301     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
1302     if (LIKELY(index <= MAX_ARRAY_INDEX)) {
1303         unsigned attributes = DontDelete | ReadOnly;
1304         slot.setValue(thisObject, attributes, jsStringOrUndefined(state, thisObject->wrapped().item(index)));
1305         return true;
1306     }
1307     return Base::getOwnPropertySlotByIndex(thisObject, state, index, slot);
1308 }
1309
1310 EncodedJSValue jsTestObjReadOnlyLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1311 {
1312     UNUSED_PARAM(state);
1313     UNUSED_PARAM(thisValue);
1314     JSValue decodedThisValue = JSValue::decode(thisValue);
1315     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1316     if (UNLIKELY(!castedThis)) {
1317         return throwGetterTypeError(*state, "TestObj", "readOnlyLongAttr");
1318     }
1319     auto& impl = castedThis->wrapped();
1320     JSValue result = jsNumber(impl.readOnlyLongAttr());
1321     return JSValue::encode(result);
1322 }
1323
1324
1325 EncodedJSValue jsTestObjReadOnlyStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1326 {
1327     UNUSED_PARAM(state);
1328     UNUSED_PARAM(thisValue);
1329     JSValue decodedThisValue = JSValue::decode(thisValue);
1330     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1331     if (UNLIKELY(!castedThis)) {
1332         return throwGetterTypeError(*state, "TestObj", "readOnlyStringAttr");
1333     }
1334     auto& impl = castedThis->wrapped();
1335     JSValue result = jsStringWithCache(state, impl.readOnlyStringAttr());
1336     return JSValue::encode(result);
1337 }
1338
1339
1340 EncodedJSValue jsTestObjReadOnlyTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1341 {
1342     UNUSED_PARAM(state);
1343     UNUSED_PARAM(thisValue);
1344     JSValue decodedThisValue = JSValue::decode(thisValue);
1345     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1346     if (UNLIKELY(!castedThis)) {
1347         return throwGetterTypeError(*state, "TestObj", "readOnlyTestObjAttr");
1348     }
1349     auto& impl = castedThis->wrapped();
1350     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.readOnlyTestObjAttr()));
1351     return JSValue::encode(result);
1352 }
1353
1354
1355 EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1356 {
1357     UNUSED_PARAM(state);
1358     UNUSED_PARAM(thisValue);
1359     JSValue result = jsNumber(TestObj::staticReadOnlyLongAttr());
1360     return JSValue::encode(result);
1361 }
1362
1363
1364 EncodedJSValue jsTestObjConstructorStaticStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1365 {
1366     UNUSED_PARAM(state);
1367     UNUSED_PARAM(thisValue);
1368     JSValue result = jsStringWithCache(state, TestObj::staticStringAttr());
1369     return JSValue::encode(result);
1370 }
1371
1372
1373 EncodedJSValue jsTestObjConstructorTestSubObj(ExecState* state, EncodedJSValue thisValue, PropertyName)
1374 {
1375     UNUSED_PARAM(state);
1376     UNUSED_PARAM(thisValue);
1377     JSValue decodedThisValue = JSValue::decode(thisValue);
1378     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1379     if (UNLIKELY(!castedThis)) {
1380         return throwGetterTypeError(*state, "TestObj", "TestSubObj");
1381     }
1382     return JSValue::encode(JSTestSubObj::getConstructor(state->vm(), castedThis->globalObject()));
1383 }
1384
1385
1386 EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
1387 {
1388     UNUSED_PARAM(state);
1389     UNUSED_PARAM(thisValue);
1390     JSValue decodedThisValue = JSValue::decode(thisValue);
1391     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1392     if (UNLIKELY(!castedThis)) {
1393         return throwGetterTypeError(*state, "TestObj", "TestSubObjEnabledBySetting");
1394     }
1395     if (UNLIKELY(!castedThis->wrapped().frame()))
1396         return JSValue::encode(jsUndefined());
1397     Settings& settings = castedThis->wrapped().frame()->settings();
1398     if (!settings.testSettingEnabled())
1399         return JSValue::encode(jsUndefined());
1400     return JSValue::encode(JSTestSubObj::getConstructor(state->vm(), castedThis->globalObject()));
1401 }
1402
1403
1404 EncodedJSValue jsTestObjEnumAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1405 {
1406     UNUSED_PARAM(state);
1407     UNUSED_PARAM(thisValue);
1408     JSValue decodedThisValue = JSValue::decode(thisValue);
1409     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1410     if (UNLIKELY(!castedThis)) {
1411         return throwGetterTypeError(*state, "TestObj", "enumAttr");
1412     }
1413     auto& impl = castedThis->wrapped();
1414     JSValue result = jsStringWithCache(state, impl.enumAttr());
1415     return JSValue::encode(result);
1416 }
1417
1418
1419 EncodedJSValue jsTestObjByteAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1420 {
1421     UNUSED_PARAM(state);
1422     UNUSED_PARAM(thisValue);
1423     JSValue decodedThisValue = JSValue::decode(thisValue);
1424     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1425     if (UNLIKELY(!castedThis)) {
1426         return throwGetterTypeError(*state, "TestObj", "byteAttr");
1427     }
1428     auto& impl = castedThis->wrapped();
1429     JSValue result = jsNumber(impl.byteAttr());
1430     return JSValue::encode(result);
1431 }
1432
1433
1434 EncodedJSValue jsTestObjOctetAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1435 {
1436     UNUSED_PARAM(state);
1437     UNUSED_PARAM(thisValue);
1438     JSValue decodedThisValue = JSValue::decode(thisValue);
1439     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1440     if (UNLIKELY(!castedThis)) {
1441         return throwGetterTypeError(*state, "TestObj", "octetAttr");
1442     }
1443     auto& impl = castedThis->wrapped();
1444     JSValue result = jsNumber(impl.octetAttr());
1445     return JSValue::encode(result);
1446 }
1447
1448
1449 EncodedJSValue jsTestObjShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1450 {
1451     UNUSED_PARAM(state);
1452     UNUSED_PARAM(thisValue);
1453     JSValue decodedThisValue = JSValue::decode(thisValue);
1454     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1455     if (UNLIKELY(!castedThis)) {
1456         return throwGetterTypeError(*state, "TestObj", "shortAttr");
1457     }
1458     auto& impl = castedThis->wrapped();
1459     JSValue result = jsNumber(impl.shortAttr());
1460     return JSValue::encode(result);
1461 }
1462
1463
1464 EncodedJSValue jsTestObjClampedShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1465 {
1466     UNUSED_PARAM(state);
1467     UNUSED_PARAM(thisValue);
1468     JSValue decodedThisValue = JSValue::decode(thisValue);
1469     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1470     if (UNLIKELY(!castedThis)) {
1471         return throwGetterTypeError(*state, "TestObj", "clampedShortAttr");
1472     }
1473     auto& impl = castedThis->wrapped();
1474     JSValue result = jsNumber(impl.clampedShortAttr());
1475     return JSValue::encode(result);
1476 }
1477
1478
1479 EncodedJSValue jsTestObjEnforceRangeShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1480 {
1481     UNUSED_PARAM(state);
1482     UNUSED_PARAM(thisValue);
1483     JSValue decodedThisValue = JSValue::decode(thisValue);
1484     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1485     if (UNLIKELY(!castedThis)) {
1486         return throwGetterTypeError(*state, "TestObj", "enforceRangeShortAttr");
1487     }
1488     auto& impl = castedThis->wrapped();
1489     JSValue result = jsNumber(impl.enforceRangeShortAttr());
1490     return JSValue::encode(result);
1491 }
1492
1493
1494 EncodedJSValue jsTestObjUnsignedShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1495 {
1496     UNUSED_PARAM(state);
1497     UNUSED_PARAM(thisValue);
1498     JSValue decodedThisValue = JSValue::decode(thisValue);
1499     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1500     if (UNLIKELY(!castedThis)) {
1501         return throwGetterTypeError(*state, "TestObj", "unsignedShortAttr");
1502     }
1503     auto& impl = castedThis->wrapped();
1504     JSValue result = jsNumber(impl.unsignedShortAttr());
1505     return JSValue::encode(result);
1506 }
1507
1508
1509 EncodedJSValue jsTestObjLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1510 {
1511     UNUSED_PARAM(state);
1512     UNUSED_PARAM(thisValue);
1513     JSValue decodedThisValue = JSValue::decode(thisValue);
1514     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1515     if (UNLIKELY(!castedThis)) {
1516         return throwGetterTypeError(*state, "TestObj", "longAttr");
1517     }
1518     auto& impl = castedThis->wrapped();
1519     JSValue result = jsNumber(impl.longAttr());
1520     return JSValue::encode(result);
1521 }
1522
1523
1524 EncodedJSValue jsTestObjLongLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1525 {
1526     UNUSED_PARAM(state);
1527     UNUSED_PARAM(thisValue);
1528     JSValue decodedThisValue = JSValue::decode(thisValue);
1529     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1530     if (UNLIKELY(!castedThis)) {
1531         return throwGetterTypeError(*state, "TestObj", "longLongAttr");
1532     }
1533     auto& impl = castedThis->wrapped();
1534     JSValue result = jsNumber(impl.longLongAttr());
1535     return JSValue::encode(result);
1536 }
1537
1538
1539 EncodedJSValue jsTestObjUnsignedLongLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1540 {
1541     UNUSED_PARAM(state);
1542     UNUSED_PARAM(thisValue);
1543     JSValue decodedThisValue = JSValue::decode(thisValue);
1544     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1545     if (UNLIKELY(!castedThis)) {
1546         return throwGetterTypeError(*state, "TestObj", "unsignedLongLongAttr");
1547     }
1548     auto& impl = castedThis->wrapped();
1549     JSValue result = jsNumber(impl.unsignedLongLongAttr());
1550     return JSValue::encode(result);
1551 }
1552
1553
1554 EncodedJSValue jsTestObjStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1555 {
1556     UNUSED_PARAM(state);
1557     UNUSED_PARAM(thisValue);
1558     JSValue decodedThisValue = JSValue::decode(thisValue);
1559     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1560     if (UNLIKELY(!castedThis)) {
1561         return throwGetterTypeError(*state, "TestObj", "stringAttr");
1562     }
1563     auto& impl = castedThis->wrapped();
1564     JSValue result = jsStringWithCache(state, impl.stringAttr());
1565     return JSValue::encode(result);
1566 }
1567
1568
1569 EncodedJSValue jsTestObjTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1570 {
1571     UNUSED_PARAM(state);
1572     UNUSED_PARAM(thisValue);
1573     JSValue decodedThisValue = JSValue::decode(thisValue);
1574     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1575     if (UNLIKELY(!castedThis)) {
1576         return throwGetterTypeError(*state, "TestObj", "testObjAttr");
1577     }
1578     auto& impl = castedThis->wrapped();
1579     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.testObjAttr()));
1580     return JSValue::encode(result);
1581 }
1582
1583
1584 EncodedJSValue jsTestObjTestNullableObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1585 {
1586     UNUSED_PARAM(state);
1587     UNUSED_PARAM(thisValue);
1588     JSValue decodedThisValue = JSValue::decode(thisValue);
1589     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1590     if (UNLIKELY(!castedThis)) {
1591         return throwGetterTypeError(*state, "TestObj", "testNullableObjAttr");
1592     }
1593     auto& impl = castedThis->wrapped();
1594     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.testNullableObjAttr()));
1595     return JSValue::encode(result);
1596 }
1597
1598
1599 EncodedJSValue jsTestObjLenientTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1600 {
1601     UNUSED_PARAM(state);
1602     UNUSED_PARAM(thisValue);
1603     JSValue decodedThisValue = JSValue::decode(thisValue);
1604     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1605     if (UNLIKELY(!castedThis)) {
1606         return JSValue::encode(jsUndefined());
1607     }
1608     auto& impl = castedThis->wrapped();
1609     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.lenientTestObjAttr()));
1610     return JSValue::encode(result);
1611 }
1612
1613
1614 EncodedJSValue jsTestObjUnforgeableAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1615 {
1616     UNUSED_PARAM(state);
1617     UNUSED_PARAM(thisValue);
1618     JSValue decodedThisValue = JSValue::decode(thisValue);
1619     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1620     if (UNLIKELY(!castedThis)) {
1621         return throwGetterTypeError(*state, "TestObj", "unforgeableAttr");
1622     }
1623     auto& impl = castedThis->wrapped();
1624     JSValue result = jsStringWithCache(state, impl.unforgeableAttr());
1625     return JSValue::encode(result);
1626 }
1627
1628
1629 EncodedJSValue jsTestObjStringAttrTreatingNullAsEmptyString(ExecState* state, EncodedJSValue thisValue, PropertyName)
1630 {
1631     UNUSED_PARAM(state);
1632     UNUSED_PARAM(thisValue);
1633     JSValue decodedThisValue = JSValue::decode(thisValue);
1634     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1635     if (UNLIKELY(!castedThis)) {
1636         return throwGetterTypeError(*state, "TestObj", "stringAttrTreatingNullAsEmptyString");
1637     }
1638     auto& impl = castedThis->wrapped();
1639     JSValue result = jsStringWithCache(state, impl.stringAttrTreatingNullAsEmptyString());
1640     return JSValue::encode(result);
1641 }
1642
1643
1644 EncodedJSValue jsTestObjXMLObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1645 {
1646     UNUSED_PARAM(state);
1647     UNUSED_PARAM(thisValue);
1648     JSValue decodedThisValue = JSValue::decode(thisValue);
1649     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1650     if (UNLIKELY(!castedThis)) {
1651         return throwGetterTypeError(*state, "TestObj", "XMLObjAttr");
1652     }
1653     auto& impl = castedThis->wrapped();
1654     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.xmlObjAttr()));
1655     return JSValue::encode(result);
1656 }
1657
1658
1659 EncodedJSValue jsTestObjCreate(ExecState* state, EncodedJSValue thisValue, PropertyName)
1660 {
1661     UNUSED_PARAM(state);
1662     UNUSED_PARAM(thisValue);
1663     JSValue decodedThisValue = JSValue::decode(thisValue);
1664     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1665     if (UNLIKELY(!castedThis)) {
1666         return throwGetterTypeError(*state, "TestObj", "create");
1667     }
1668     auto& impl = castedThis->wrapped();
1669     JSValue result = jsBoolean(impl.isCreate());
1670     return JSValue::encode(result);
1671 }
1672
1673
1674 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1675 {
1676     UNUSED_PARAM(state);
1677     UNUSED_PARAM(thisValue);
1678     JSValue decodedThisValue = JSValue::decode(thisValue);
1679     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1680     if (UNLIKELY(!castedThis)) {
1681         return throwGetterTypeError(*state, "TestObj", "reflectedStringAttr");
1682     }
1683     auto& impl = castedThis->wrapped();
1684     JSValue result = jsStringWithCache(state, impl.fastGetAttribute(WebCore::HTMLNames::reflectedstringattrAttr));
1685     return JSValue::encode(result);
1686 }
1687
1688
1689 EncodedJSValue jsTestObjReflectedIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1690 {
1691     UNUSED_PARAM(state);
1692     UNUSED_PARAM(thisValue);
1693     JSValue decodedThisValue = JSValue::decode(thisValue);
1694     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1695     if (UNLIKELY(!castedThis)) {
1696         return throwGetterTypeError(*state, "TestObj", "reflectedIntegralAttr");
1697     }
1698     auto& impl = castedThis->wrapped();
1699     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr));
1700     return JSValue::encode(result);
1701 }
1702
1703
1704 EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1705 {
1706     UNUSED_PARAM(state);
1707     UNUSED_PARAM(thisValue);
1708     JSValue decodedThisValue = JSValue::decode(thisValue);
1709     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1710     if (UNLIKELY(!castedThis)) {
1711         return throwGetterTypeError(*state, "TestObj", "reflectedUnsignedIntegralAttr");
1712     }
1713     auto& impl = castedThis->wrapped();
1714     JSValue result = jsNumber(std::max(0, impl.getIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr)));
1715     return JSValue::encode(result);
1716 }
1717
1718
1719 EncodedJSValue jsTestObjReflectedBooleanAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1720 {
1721     UNUSED_PARAM(state);
1722     UNUSED_PARAM(thisValue);
1723     JSValue decodedThisValue = JSValue::decode(thisValue);
1724     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1725     if (UNLIKELY(!castedThis)) {
1726         return throwGetterTypeError(*state, "TestObj", "reflectedBooleanAttr");
1727     }
1728     auto& impl = castedThis->wrapped();
1729     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr));
1730     return JSValue::encode(result);
1731 }
1732
1733
1734 EncodedJSValue jsTestObjReflectedURLAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1735 {
1736     UNUSED_PARAM(state);
1737     UNUSED_PARAM(thisValue);
1738     JSValue decodedThisValue = JSValue::decode(thisValue);
1739     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1740     if (UNLIKELY(!castedThis)) {
1741         return throwGetterTypeError(*state, "TestObj", "reflectedURLAttr");
1742     }
1743     auto& impl = castedThis->wrapped();
1744     JSValue result = jsStringWithCache(state, impl.getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr));
1745     return JSValue::encode(result);
1746 }
1747
1748
1749 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1750 {
1751     UNUSED_PARAM(state);
1752     UNUSED_PARAM(thisValue);
1753     JSValue decodedThisValue = JSValue::decode(thisValue);
1754     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1755     if (UNLIKELY(!castedThis)) {
1756         return throwGetterTypeError(*state, "TestObj", "reflectedStringAttr");
1757     }
1758     auto& impl = castedThis->wrapped();
1759     JSValue result = jsStringWithCache(state, impl.fastGetAttribute(WebCore::HTMLNames::customContentStringAttrAttr));
1760     return JSValue::encode(result);
1761 }
1762
1763
1764 EncodedJSValue jsTestObjReflectedCustomIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1765 {
1766     UNUSED_PARAM(state);
1767     UNUSED_PARAM(thisValue);
1768     JSValue decodedThisValue = JSValue::decode(thisValue);
1769     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1770     if (UNLIKELY(!castedThis)) {
1771         return throwGetterTypeError(*state, "TestObj", "reflectedCustomIntegralAttr");
1772     }
1773     auto& impl = castedThis->wrapped();
1774     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr));
1775     return JSValue::encode(result);
1776 }
1777
1778
1779 EncodedJSValue jsTestObjReflectedCustomBooleanAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1780 {
1781     UNUSED_PARAM(state);
1782     UNUSED_PARAM(thisValue);
1783     JSValue decodedThisValue = JSValue::decode(thisValue);
1784     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1785     if (UNLIKELY(!castedThis)) {
1786         return throwGetterTypeError(*state, "TestObj", "reflectedCustomBooleanAttr");
1787     }
1788     auto& impl = castedThis->wrapped();
1789     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr));
1790     return JSValue::encode(result);
1791 }
1792
1793
1794 EncodedJSValue jsTestObjReflectedCustomURLAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1795 {
1796     UNUSED_PARAM(state);
1797     UNUSED_PARAM(thisValue);
1798     JSValue decodedThisValue = JSValue::decode(thisValue);
1799     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1800     if (UNLIKELY(!castedThis)) {
1801         return throwGetterTypeError(*state, "TestObj", "reflectedCustomURLAttr");
1802     }
1803     auto& impl = castedThis->wrapped();
1804     JSValue result = jsStringWithCache(state, impl.getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr));
1805     return JSValue::encode(result);
1806 }
1807
1808
1809 #if ENABLE(TEST_FEATURE)
1810 EncodedJSValue jsTestObjEnabledAtRuntimeAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1811 {
1812     UNUSED_PARAM(state);
1813     UNUSED_PARAM(thisValue);
1814     JSValue decodedThisValue = JSValue::decode(thisValue);
1815     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1816     if (UNLIKELY(!castedThis)) {
1817         return throwGetterTypeError(*state, "TestObj", "enabledAtRuntimeAttribute");
1818     }
1819     auto& impl = castedThis->wrapped();
1820     JSValue result = jsStringWithCache(state, impl.enabledAtRuntimeAttribute());
1821     return JSValue::encode(result);
1822 }
1823
1824 #endif
1825
1826 EncodedJSValue jsTestObjTypedArrayAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1827 {
1828     UNUSED_PARAM(state);
1829     UNUSED_PARAM(thisValue);
1830     JSValue decodedThisValue = JSValue::decode(thisValue);
1831     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1832     if (UNLIKELY(!castedThis)) {
1833         return throwGetterTypeError(*state, "TestObj", "typedArrayAttr");
1834     }
1835     auto& impl = castedThis->wrapped();
1836     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.typedArrayAttr()));
1837     return JSValue::encode(result);
1838 }
1839
1840
1841 EncodedJSValue jsTestObjAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1842 {
1843     UNUSED_PARAM(state);
1844     UNUSED_PARAM(thisValue);
1845     JSValue decodedThisValue = JSValue::decode(thisValue);
1846     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1847     if (UNLIKELY(!castedThis)) {
1848         return throwGetterTypeError(*state, "TestObj", "attrWithGetterException");
1849     }
1850     ExceptionCode ec = 0;
1851     auto& impl = castedThis->wrapped();
1852     JSValue result = jsNumber(impl.attrWithGetterException(ec));
1853     setDOMException(state, ec);
1854     return JSValue::encode(result);
1855 }
1856
1857
1858 EncodedJSValue jsTestObjAttrWithGetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, PropertyName)
1859 {
1860     UNUSED_PARAM(state);
1861     UNUSED_PARAM(thisValue);
1862     JSValue decodedThisValue = JSValue::decode(thisValue);
1863     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1864     if (UNLIKELY(!castedThis)) {
1865         return throwGetterTypeError(*state, "TestObj", "attrWithGetterExceptionWithMessage");
1866     }
1867     ExceptionCodeWithMessage ec;
1868     auto& impl = castedThis->wrapped();
1869     JSValue result = jsNumber(impl.attrWithGetterExceptionWithMessage(ec));
1870     setDOMException(state, ec);
1871     return JSValue::encode(result);
1872 }
1873
1874
1875 EncodedJSValue jsTestObjAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1876 {
1877     UNUSED_PARAM(state);
1878     UNUSED_PARAM(thisValue);
1879     JSValue decodedThisValue = JSValue::decode(thisValue);
1880     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1881     if (UNLIKELY(!castedThis)) {
1882         return throwGetterTypeError(*state, "TestObj", "attrWithSetterException");
1883     }
1884     auto& impl = castedThis->wrapped();
1885     JSValue result = jsNumber(impl.attrWithSetterException());
1886     return JSValue::encode(result);
1887 }
1888
1889
1890 EncodedJSValue jsTestObjAttrWithSetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, PropertyName)
1891 {
1892     UNUSED_PARAM(state);
1893     UNUSED_PARAM(thisValue);
1894     JSValue decodedThisValue = JSValue::decode(thisValue);
1895     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1896     if (UNLIKELY(!castedThis)) {
1897         return throwGetterTypeError(*state, "TestObj", "attrWithSetterExceptionWithMessage");
1898     }
1899     auto& impl = castedThis->wrapped();
1900     JSValue result = jsNumber(impl.attrWithSetterExceptionWithMessage());
1901     return JSValue::encode(result);
1902 }
1903
1904
1905 EncodedJSValue jsTestObjStringAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1906 {
1907     UNUSED_PARAM(state);
1908     UNUSED_PARAM(thisValue);
1909     JSValue decodedThisValue = JSValue::decode(thisValue);
1910     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1911     if (UNLIKELY(!castedThis)) {
1912         return throwGetterTypeError(*state, "TestObj", "stringAttrWithGetterException");
1913     }
1914     ExceptionCode ec = 0;
1915     auto& impl = castedThis->wrapped();
1916     JSValue result = jsStringWithCache(state, impl.stringAttrWithGetterException(ec));
1917     setDOMException(state, ec);
1918     return JSValue::encode(result);
1919 }
1920
1921
1922 EncodedJSValue jsTestObjStringAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1923 {
1924     UNUSED_PARAM(state);
1925     UNUSED_PARAM(thisValue);
1926     JSValue decodedThisValue = JSValue::decode(thisValue);
1927     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1928     if (UNLIKELY(!castedThis)) {
1929         return throwGetterTypeError(*state, "TestObj", "stringAttrWithSetterException");
1930     }
1931     auto& impl = castedThis->wrapped();
1932     JSValue result = jsStringWithCache(state, impl.stringAttrWithSetterException());
1933     return JSValue::encode(result);
1934 }
1935
1936
1937 EncodedJSValue jsTestObjStrictTypeCheckingAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1938 {
1939     UNUSED_PARAM(state);
1940     UNUSED_PARAM(thisValue);
1941     JSValue decodedThisValue = JSValue::decode(thisValue);
1942     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1943     if (UNLIKELY(!castedThis)) {
1944         return throwGetterTypeError(*state, "TestObj", "strictTypeCheckingAttribute");
1945     }
1946     auto& impl = castedThis->wrapped();
1947     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.strictTypeCheckingAttribute()));
1948     return JSValue::encode(result);
1949 }
1950
1951
1952 EncodedJSValue jsTestObjCustomAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1953 {
1954     UNUSED_PARAM(state);
1955     UNUSED_PARAM(thisValue);
1956     JSValue decodedThisValue = JSValue::decode(thisValue);
1957     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1958     if (UNLIKELY(!castedThis)) {
1959         return throwGetterTypeError(*state, "TestObj", "customAttr");
1960     }
1961     return JSValue::encode(castedThis->customAttr(*state));
1962 }
1963
1964
1965 EncodedJSValue jsTestObjOnfoo(ExecState* state, EncodedJSValue thisValue, PropertyName)
1966 {
1967     UNUSED_PARAM(state);
1968     UNUSED_PARAM(thisValue);
1969     JSValue decodedThisValue = JSValue::decode(thisValue);
1970     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1971     if (UNLIKELY(!castedThis)) {
1972         return throwGetterTypeError(*state, "TestObj", "onfoo");
1973     }
1974     UNUSED_PARAM(state);
1975     return JSValue::encode(eventHandlerAttribute(castedThis->wrapped(), eventNames().fooEvent));
1976 }
1977
1978
1979 EncodedJSValue jsTestObjOnwebkitfoo(ExecState* state, EncodedJSValue thisValue, PropertyName)
1980 {
1981     UNUSED_PARAM(state);
1982     UNUSED_PARAM(thisValue);
1983     JSValue decodedThisValue = JSValue::decode(thisValue);
1984     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1985     if (UNLIKELY(!castedThis)) {
1986         return throwGetterTypeError(*state, "TestObj", "onwebkitfoo");
1987     }
1988     UNUSED_PARAM(state);
1989     return JSValue::encode(eventHandlerAttribute(castedThis->wrapped(), eventNames().fooEvent));
1990 }
1991
1992
1993 EncodedJSValue jsTestObjWithScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1994 {
1995     UNUSED_PARAM(state);
1996     UNUSED_PARAM(thisValue);
1997     JSValue decodedThisValue = JSValue::decode(thisValue);
1998     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1999     if (UNLIKELY(!castedThis)) {
2000         return throwGetterTypeError(*state, "TestObj", "withScriptStateAttribute");
2001     }
2002     auto& impl = castedThis->wrapped();
2003     JSValue result = jsNumber(impl.withScriptStateAttribute(*state));
2004     return JSValue::encode(result);
2005 }
2006
2007
2008 EncodedJSValue jsTestObjWithCallWithAndSetterCallWithAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2009 {
2010     UNUSED_PARAM(state);
2011     UNUSED_PARAM(thisValue);
2012     JSValue decodedThisValue = JSValue::decode(thisValue);
2013     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2014     if (UNLIKELY(!castedThis)) {
2015         return throwGetterTypeError(*state, "TestObj", "withCallWithAndSetterCallWithAttribute");
2016     }
2017     auto& impl = castedThis->wrapped();
2018     JSValue result = jsNumber(impl.withCallWithAndSetterCallWithAttribute(*state));
2019     return JSValue::encode(result);
2020 }
2021
2022
2023 EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2024 {
2025     UNUSED_PARAM(state);
2026     UNUSED_PARAM(thisValue);
2027     JSValue decodedThisValue = JSValue::decode(thisValue);
2028     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2029     if (UNLIKELY(!castedThis)) {
2030         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAttribute");
2031     }
2032     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2033     if (!context)
2034         return JSValue::encode(jsUndefined());
2035     auto& impl = castedThis->wrapped();
2036     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttribute(*context)));
2037     return JSValue::encode(result);
2038 }
2039
2040
2041 EncodedJSValue jsTestObjWithScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
2042 {
2043     UNUSED_PARAM(state);
2044     UNUSED_PARAM(thisValue);
2045     JSValue decodedThisValue = JSValue::decode(thisValue);
2046     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2047     if (UNLIKELY(!castedThis)) {
2048         return throwGetterTypeError(*state, "TestObj", "withScriptStateAttributeRaises");
2049     }
2050     ExceptionCode ec = 0;
2051     auto& impl = castedThis->wrapped();
2052     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(*state, ec)));
2053     setDOMException(state, ec);
2054     return JSValue::encode(result);
2055 }
2056
2057
2058 EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
2059 {
2060     UNUSED_PARAM(state);
2061     UNUSED_PARAM(thisValue);
2062     JSValue decodedThisValue = JSValue::decode(thisValue);
2063     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2064     if (UNLIKELY(!castedThis)) {
2065         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAttributeRaises");
2066     }
2067     ExceptionCode ec = 0;
2068     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2069     if (!context)
2070         return JSValue::encode(jsUndefined());
2071     auto& impl = castedThis->wrapped();
2072     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(*context, ec)));
2073     setDOMException(state, ec);
2074     return JSValue::encode(result);
2075 }
2076
2077
2078 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2079 {
2080     UNUSED_PARAM(state);
2081     UNUSED_PARAM(thisValue);
2082     JSValue decodedThisValue = JSValue::decode(thisValue);
2083     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2084     if (UNLIKELY(!castedThis)) {
2085         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
2086     }
2087     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2088     if (!context)
2089         return JSValue::encode(jsUndefined());
2090     auto& impl = castedThis->wrapped();
2091     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttribute(*state, *context)));
2092     return JSValue::encode(result);
2093 }
2094
2095
2096 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
2097 {
2098     UNUSED_PARAM(state);
2099     UNUSED_PARAM(thisValue);
2100     JSValue decodedThisValue = JSValue::decode(thisValue);
2101     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2102     if (UNLIKELY(!castedThis)) {
2103         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
2104     }
2105     ExceptionCode ec = 0;
2106     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2107     if (!context)
2108         return JSValue::encode(jsUndefined());
2109     auto& impl = castedThis->wrapped();
2110     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(*state, *context, ec)));
2111     setDOMException(state, ec);
2112     return JSValue::encode(result);
2113 }
2114
2115
2116 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2117 {
2118     UNUSED_PARAM(state);
2119     UNUSED_PARAM(thisValue);
2120     JSValue decodedThisValue = JSValue::decode(thisValue);
2121     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2122     if (UNLIKELY(!castedThis)) {
2123         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
2124     }
2125     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2126     if (!context)
2127         return JSValue::encode(jsUndefined());
2128     auto& impl = castedThis->wrapped();
2129     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpacesAttribute(*state, *context)));
2130     return JSValue::encode(result);
2131 }
2132
2133
2134 EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2135 {
2136     UNUSED_PARAM(state);
2137     UNUSED_PARAM(thisValue);
2138     JSValue decodedThisValue = JSValue::decode(thisValue);
2139     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2140     if (UNLIKELY(!castedThis)) {
2141         return throwGetterTypeError(*state, "TestObj", "withScriptArgumentsAndCallStackAttribute");
2142     }
2143     auto& impl = castedThis->wrapped();
2144     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptArgumentsAndCallStackAttribute()));
2145     return JSValue::encode(result);
2146 }
2147
2148
2149 #if ENABLE(Condition1)
2150 EncodedJSValue jsTestObjConditionalAttr1(ExecState* state, EncodedJSValue thisValue, PropertyName)
2151 {
2152     UNUSED_PARAM(state);
2153     UNUSED_PARAM(thisValue);
2154     JSValue decodedThisValue = JSValue::decode(thisValue);
2155     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2156     if (UNLIKELY(!castedThis)) {
2157         return throwGetterTypeError(*state, "TestObj", "conditionalAttr1");
2158     }
2159     auto& impl = castedThis->wrapped();
2160     JSValue result = jsNumber(impl.conditionalAttr1());
2161     return JSValue::encode(result);
2162 }
2163
2164 #endif
2165
2166 #if ENABLE(Condition1) && ENABLE(Condition2)
2167 EncodedJSValue jsTestObjConditionalAttr2(ExecState* state, EncodedJSValue thisValue, PropertyName)
2168 {
2169     UNUSED_PARAM(state);
2170     UNUSED_PARAM(thisValue);
2171     JSValue decodedThisValue = JSValue::decode(thisValue);
2172     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2173     if (UNLIKELY(!castedThis)) {
2174         return throwGetterTypeError(*state, "TestObj", "conditionalAttr2");
2175     }
2176     auto& impl = castedThis->wrapped();
2177     JSValue result = jsNumber(impl.conditionalAttr2());
2178     return JSValue::encode(result);
2179 }
2180
2181 #endif
2182
2183 #if ENABLE(Condition1) || ENABLE(Condition2)
2184 EncodedJSValue jsTestObjConditionalAttr3(ExecState* state, EncodedJSValue thisValue, PropertyName)
2185 {
2186     UNUSED_PARAM(state);
2187     UNUSED_PARAM(thisValue);
2188     JSValue decodedThisValue = JSValue::decode(thisValue);
2189     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2190     if (UNLIKELY(!castedThis)) {
2191         return throwGetterTypeError(*state, "TestObj", "conditionalAttr3");
2192     }
2193     auto& impl = castedThis->wrapped();
2194     JSValue result = jsNumber(impl.conditionalAttr3());
2195     return JSValue::encode(result);
2196 }
2197
2198 #endif
2199
2200 #if ENABLE(Condition1)
2201 EncodedJSValue jsTestObjConditionalAttr4Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2202 {
2203     UNUSED_PARAM(state);
2204     UNUSED_PARAM(thisValue);
2205     JSValue decodedThisValue = JSValue::decode(thisValue);
2206     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2207     if (UNLIKELY(!castedThis)) {
2208         return throwGetterTypeError(*state, "TestObj", "conditionalAttr4");
2209     }
2210     return JSValue::encode(JSTestObjectA::getConstructor(state->vm(), castedThis->globalObject()));
2211 }
2212
2213 #endif
2214
2215 #if ENABLE(Condition1) && ENABLE(Condition2)
2216 EncodedJSValue jsTestObjConditionalAttr5Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2217 {
2218     UNUSED_PARAM(state);
2219     UNUSED_PARAM(thisValue);
2220     JSValue decodedThisValue = JSValue::decode(thisValue);
2221     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2222     if (UNLIKELY(!castedThis)) {
2223         return throwGetterTypeError(*state, "TestObj", "conditionalAttr5");
2224     }
2225     return JSValue::encode(JSTestObjectB::getConstructor(state->vm(), castedThis->globalObject()));
2226 }
2227
2228 #endif
2229
2230 #if ENABLE(Condition1) || ENABLE(Condition2)
2231 EncodedJSValue jsTestObjConditionalAttr6Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2232 {
2233     UNUSED_PARAM(state);
2234     UNUSED_PARAM(thisValue);
2235     JSValue decodedThisValue = JSValue::decode(thisValue);
2236     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2237     if (UNLIKELY(!castedThis)) {
2238         return throwGetterTypeError(*state, "TestObj", "conditionalAttr6");
2239     }
2240     return JSValue::encode(JSTestObjectC::getConstructor(state->vm(), castedThis->globalObject()));
2241 }
2242
2243 #endif
2244
2245 EncodedJSValue jsTestObjCachedAttribute1(ExecState* state, EncodedJSValue thisValue, PropertyName)
2246 {
2247     UNUSED_PARAM(state);
2248     UNUSED_PARAM(thisValue);
2249     JSValue decodedThisValue = JSValue::decode(thisValue);
2250     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2251     if (UNLIKELY(!castedThis)) {
2252         return throwGetterTypeError(*state, "TestObj", "cachedAttribute1");
2253     }
2254     if (JSValue cachedValue = castedThis->m_cachedAttribute1.get())
2255         return JSValue::encode(cachedValue);
2256     auto& impl = castedThis->wrapped();
2257     JSValue result = impl.cachedAttribute1();
2258     castedThis->m_cachedAttribute1.set(state->vm(), castedThis, result);
2259     return JSValue::encode(result);
2260 }
2261
2262
2263 EncodedJSValue jsTestObjCachedAttribute2(ExecState* state, EncodedJSValue thisValue, PropertyName)
2264 {
2265     UNUSED_PARAM(state);
2266     UNUSED_PARAM(thisValue);
2267     JSValue decodedThisValue = JSValue::decode(thisValue);
2268     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2269     if (UNLIKELY(!castedThis)) {
2270         return throwGetterTypeError(*state, "TestObj", "cachedAttribute2");
2271     }
2272     if (JSValue cachedValue = castedThis->m_cachedAttribute2.get())
2273         return JSValue::encode(cachedValue);
2274     auto& impl = castedThis->wrapped();
2275     JSValue result = impl.cachedAttribute2();
2276     castedThis->m_cachedAttribute2.set(state->vm(), castedThis, result);
2277     return JSValue::encode(result);
2278 }
2279
2280
2281 EncodedJSValue jsTestObjAnyAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2282 {
2283     UNUSED_PARAM(state);
2284     UNUSED_PARAM(thisValue);
2285     JSValue decodedThisValue = JSValue::decode(thisValue);
2286     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2287     if (UNLIKELY(!castedThis)) {
2288         return throwGetterTypeError(*state, "TestObj", "anyAttribute");
2289     }
2290     auto& impl = castedThis->wrapped();
2291     JSValue result = impl.anyAttribute();
2292     return JSValue::encode(result);
2293 }
2294
2295
2296 EncodedJSValue jsTestObjContentDocument(ExecState* state, EncodedJSValue thisValue, PropertyName)
2297 {
2298     UNUSED_PARAM(state);
2299     UNUSED_PARAM(thisValue);
2300     JSValue decodedThisValue = JSValue::decode(thisValue);
2301     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2302     if (UNLIKELY(!castedThis)) {
2303         return throwGetterTypeError(*state, "TestObj", "contentDocument");
2304     }
2305     auto& impl = castedThis->wrapped();
2306     return JSValue::encode(shouldAllowAccessToNode(state, impl.contentDocument()) ? toJS(state, castedThis->globalObject(), WTF::getPtr(impl.contentDocument())) : jsNull());
2307 }
2308
2309
2310 EncodedJSValue jsTestObjMutablePoint(ExecState* state, EncodedJSValue thisValue, PropertyName)
2311 {
2312     UNUSED_PARAM(state);
2313     UNUSED_PARAM(thisValue);
2314     JSValue decodedThisValue = JSValue::decode(thisValue);
2315     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2316     if (UNLIKELY(!castedThis)) {
2317         return throwGetterTypeError(*state, "TestObj", "mutablePoint");
2318     }
2319     auto& impl = castedThis->wrapped();
2320     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(SVGStaticPropertyTearOff<TestObj, SVGPoint>::create(impl, impl.mutablePoint(), &TestObj::updateMutablePoint)));
2321     return JSValue::encode(result);
2322 }
2323
2324
2325 EncodedJSValue jsTestObjImmutablePoint(ExecState* state, EncodedJSValue thisValue, PropertyName)
2326 {
2327     UNUSED_PARAM(state);
2328     UNUSED_PARAM(thisValue);
2329     JSValue decodedThisValue = JSValue::decode(thisValue);
2330     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2331     if (UNLIKELY(!castedThis)) {
2332         return throwGetterTypeError(*state, "TestObj", "immutablePoint");
2333     }
2334     auto& impl = castedThis->wrapped();
2335     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePoint())));
2336     return JSValue::encode(result);
2337 }
2338
2339
2340 EncodedJSValue jsTestObjStrawberry(ExecState* state, EncodedJSValue thisValue, PropertyName)
2341 {
2342     UNUSED_PARAM(state);
2343     UNUSED_PARAM(thisValue);
2344     JSValue decodedThisValue = JSValue::decode(thisValue);
2345     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2346     if (UNLIKELY(!castedThis)) {
2347         return throwGetterTypeError(*state, "TestObj", "strawberry");
2348     }
2349     auto& impl = castedThis->wrapped();
2350     JSValue result = jsNumber(impl.blueberry());
2351     return JSValue::encode(result);
2352 }
2353
2354
2355 EncodedJSValue jsTestObjStrictFloat(ExecState* state, EncodedJSValue thisValue, PropertyName)
2356 {
2357     UNUSED_PARAM(state);
2358     UNUSED_PARAM(thisValue);
2359     JSValue decodedThisValue = JSValue::decode(thisValue);
2360     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2361     if (UNLIKELY(!castedThis)) {
2362         return throwGetterTypeError(*state, "TestObj", "strictFloat");
2363     }
2364     auto& impl = castedThis->wrapped();
2365     JSValue result = jsNumber(impl.strictFloat());
2366     return JSValue::encode(result);
2367 }
2368
2369
2370 EncodedJSValue jsTestObjDescription(ExecState* state, EncodedJSValue thisValue, PropertyName)
2371 {
2372     UNUSED_PARAM(state);
2373     UNUSED_PARAM(thisValue);
2374     JSValue decodedThisValue = JSValue::decode(thisValue);
2375     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2376     if (UNLIKELY(!castedThis)) {
2377         return throwGetterTypeError(*state, "TestObj", "description");
2378     }
2379     auto& impl = castedThis->wrapped();
2380     JSValue result = jsNumber(impl.description());
2381     return JSValue::encode(result);
2382 }
2383
2384
2385 EncodedJSValue jsTestObjId(ExecState* state, EncodedJSValue thisValue, PropertyName)
2386 {
2387     UNUSED_PARAM(state);
2388     UNUSED_PARAM(thisValue);
2389     JSValue decodedThisValue = JSValue::decode(thisValue);
2390     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2391     if (UNLIKELY(!castedThis)) {
2392         return throwGetterTypeError(*state, "TestObj", "id");
2393     }
2394     auto& impl = castedThis->wrapped();
2395     JSValue result = jsNumber(impl.id());
2396     return JSValue::encode(result);
2397 }
2398
2399
2400 EncodedJSValue jsTestObjHash(ExecState* state, EncodedJSValue thisValue, PropertyName)
2401 {
2402     UNUSED_PARAM(state);
2403     UNUSED_PARAM(thisValue);
2404     JSValue decodedThisValue = JSValue::decode(thisValue);
2405     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2406     if (UNLIKELY(!castedThis)) {
2407         return throwGetterTypeError(*state, "TestObj", "hash");
2408     }
2409     auto& impl = castedThis->wrapped();
2410     JSValue result = jsStringWithCache(state, impl.hash());
2411     return JSValue::encode(result);
2412 }
2413
2414
2415 EncodedJSValue jsTestObjReplaceableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2416 {
2417     UNUSED_PARAM(state);
2418     UNUSED_PARAM(thisValue);
2419     JSValue decodedThisValue = JSValue::decode(thisValue);
2420     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2421     if (UNLIKELY(!castedThis)) {
2422         return throwGetterTypeError(*state, "TestObj", "replaceableAttribute");
2423     }
2424     auto& impl = castedThis->wrapped();
2425     JSValue result = jsNumber(impl.replaceableAttribute());
2426     return JSValue::encode(result);
2427 }
2428
2429
2430 EncodedJSValue jsTestObjNullableDoubleAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2431 {
2432     UNUSED_PARAM(state);
2433     UNUSED_PARAM(thisValue);
2434     JSValue decodedThisValue = JSValue::decode(thisValue);
2435     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2436     if (UNLIKELY(!castedThis)) {
2437         return throwGetterTypeError(*state, "TestObj", "nullableDoubleAttribute");
2438     }
2439     auto& impl = castedThis->wrapped();
2440     JSValue result = toNullableJSNumber(impl.nullableDoubleAttribute());
2441     return JSValue::encode(result);
2442 }
2443
2444
2445 EncodedJSValue jsTestObjNullableLongAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2446 {
2447     UNUSED_PARAM(state);
2448     UNUSED_PARAM(thisValue);
2449     JSValue decodedThisValue = JSValue::decode(thisValue);
2450     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2451     if (UNLIKELY(!castedThis)) {
2452         return throwGetterTypeError(*state, "TestObj", "nullableLongAttribute");
2453     }
2454     auto& impl = castedThis->wrapped();
2455     JSValue result = toNullableJSNumber(impl.nullableLongAttribute());
2456     return JSValue::encode(result);
2457 }
2458
2459
2460 EncodedJSValue jsTestObjNullableBooleanAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2461 {
2462     UNUSED_PARAM(state);
2463     UNUSED_PARAM(thisValue);
2464     JSValue decodedThisValue = JSValue::decode(thisValue);
2465     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2466     if (UNLIKELY(!castedThis)) {
2467         return throwGetterTypeError(*state, "TestObj", "nullableBooleanAttribute");
2468     }
2469     auto& impl = castedThis->wrapped();
2470     JSValue result = jsBoolean(impl.nullableBooleanAttribute());
2471     return JSValue::encode(result);
2472 }
2473
2474
2475 EncodedJSValue jsTestObjNullableStringAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2476 {
2477     UNUSED_PARAM(state);
2478     UNUSED_PARAM(thisValue);
2479     JSValue decodedThisValue = JSValue::decode(thisValue);
2480     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2481     if (UNLIKELY(!castedThis)) {
2482         return throwGetterTypeError(*state, "TestObj", "nullableStringAttribute");
2483     }
2484     auto& impl = castedThis->wrapped();
2485     JSValue result = jsStringOrNull(state, impl.nullableStringAttribute());
2486     return JSValue::encode(result);
2487 }
2488
2489
2490 EncodedJSValue jsTestObjNullableLongSettableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2491 {
2492     UNUSED_PARAM(state);
2493     UNUSED_PARAM(thisValue);
2494     JSValue decodedThisValue = JSValue::decode(thisValue);
2495     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2496     if (UNLIKELY(!castedThis)) {
2497         return throwGetterTypeError(*state, "TestObj", "nullableLongSettableAttribute");
2498     }
2499     auto& impl = castedThis->wrapped();
2500     JSValue result = toNullableJSNumber(impl.nullableLongSettableAttribute());
2501     return JSValue::encode(result);
2502 }
2503
2504
2505 EncodedJSValue jsTestObjNullableStringSettableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2506 {
2507     UNUSED_PARAM(state);
2508     UNUSED_PARAM(thisValue);
2509     JSValue decodedThisValue = JSValue::decode(thisValue);
2510     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2511     if (UNLIKELY(!castedThis)) {
2512         return throwGetterTypeError(*state, "TestObj", "nullableStringSettableAttribute");
2513     }
2514     auto& impl = castedThis->wrapped();
2515     JSValue result = jsStringOrNull(state, impl.nullableStringSettableAttribute());
2516     return JSValue::encode(result);
2517 }
2518
2519
2520 EncodedJSValue jsTestObjNullableStringValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
2521 {
2522     UNUSED_PARAM(state);
2523     UNUSED_PARAM(thisValue);
2524     JSValue decodedThisValue = JSValue::decode(thisValue);
2525     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2526     if (UNLIKELY(!castedThis)) {
2527         return throwGetterTypeError(*state, "TestObj", "nullableStringValue");
2528     }
2529     ExceptionCode ec = 0;
2530     auto& impl = castedThis->wrapped();
2531     JSValue result = toNullableJSNumber(impl.nullableStringValue(ec));
2532     setDOMException(state, ec);
2533     return JSValue::encode(result);
2534 }
2535
2536
2537 EncodedJSValue jsTestObjAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2538 {
2539     UNUSED_PARAM(state);
2540     UNUSED_PARAM(thisValue);
2541     JSValue decodedThisValue = JSValue::decode(thisValue);
2542     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2543     if (UNLIKELY(!castedThis)) {
2544         return throwGetterTypeError(*state, "TestObj", "attribute");
2545     }
2546     auto& impl = castedThis->wrapped();
2547     JSValue result = jsStringWithCache(state, impl.attribute());
2548     return JSValue::encode(result);
2549 }
2550
2551
2552 EncodedJSValue jsTestObjAttributeWithReservedEnumType(ExecState* state, EncodedJSValue thisValue, PropertyName)
2553 {
2554     UNUSED_PARAM(state);
2555     UNUSED_PARAM(thisValue);
2556     JSValue decodedThisValue = JSValue::decode(thisValue);
2557     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2558     if (UNLIKELY(!castedThis)) {
2559         return throwGetterTypeError(*state, "TestObj", "attributeWithReservedEnumType");
2560     }
2561     auto& impl = castedThis->wrapped();
2562     JSValue result = jsStringWithCache(state, impl.attributeWithReservedEnumType());
2563     return JSValue::encode(result);
2564 }
2565
2566
2567 EncodedJSValue jsTestObjPutForwardsAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2568 {
2569     UNUSED_PARAM(state);
2570     UNUSED_PARAM(thisValue);
2571     JSValue decodedThisValue = JSValue::decode(thisValue);
2572     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2573     if (UNLIKELY(!castedThis)) {
2574         return throwGetterTypeError(*state, "TestObj", "putForwardsAttribute");
2575     }
2576     auto& impl = castedThis->wrapped();
2577     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.putForwardsAttribute()));
2578     return JSValue::encode(result);
2579 }
2580
2581
2582 EncodedJSValue jsTestObjPutForwardsNullableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2583 {
2584     UNUSED_PARAM(state);
2585     UNUSED_PARAM(thisValue);
2586     JSValue decodedThisValue = JSValue::decode(thisValue);
2587     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2588     if (UNLIKELY(!castedThis)) {
2589         return throwGetterTypeError(*state, "TestObj", "putForwardsNullableAttribute");
2590     }
2591     auto& impl = castedThis->wrapped();
2592     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.putForwardsNullableAttribute()));
2593     return JSValue::encode(result);
2594 }
2595
2596
2597 EncodedJSValue jsTestObjConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2598 {
2599     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue));
2600     if (UNLIKELY(!domObject))
2601         return throwVMTypeError(state);
2602     return JSValue::encode(JSTestObj::getConstructor(state->vm(), domObject->globalObject()));
2603 }
2604
2605 bool setJSTestObjConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2606 {
2607     JSValue value = JSValue::decode(encodedValue);
2608     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue));
2609     if (UNLIKELY(!domObject)) {
2610         throwVMTypeError(state);
2611         return false;
2612     }
2613     // Shadowing a built-in constructor
2614     return domObject->putDirect(state->vm(), state->propertyNames().constructor, value);
2615 }
2616
2617 bool setJSTestObjConstructorStaticStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2618 {
2619     JSValue value = JSValue::decode(encodedValue);
2620     auto nativeValue = value.toWTFString(state);
2621     if (UNLIKELY(state->hadException()))
2622         return false;
2623     TestObj::setStaticStringAttr(WTFMove(nativeValue));
2624     return true;
2625 }
2626
2627
2628 bool setJSTestObjTestSubObjEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2629 {
2630     JSValue value = JSValue::decode(encodedValue);
2631     UNUSED_PARAM(thisValue);
2632     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2633     if (UNLIKELY(!castedThis)) {
2634         return throwSetterTypeError(*state, "TestObj", "TestSubObjEnabledBySetting");
2635     }
2636     // Shadowing a built-in constructor.
2637     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "TestSubObjEnabledBySetting"), value);
2638 }
2639
2640
2641 bool setJSTestObjEnumAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2642 {
2643     JSValue value = JSValue::decode(encodedValue);
2644     UNUSED_PARAM(thisValue);
2645     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2646     if (UNLIKELY(!castedThis)) {
2647         return throwSetterTypeError(*state, "TestObj", "enumAttr");
2648     }
2649     auto& impl = castedThis->wrapped();
2650     auto nativeValue = parse<TestObj::EnumType>(*state, value);
2651     if (UNLIKELY(state->hadException()))
2652         return false;
2653     if (UNLIKELY(!nativeValue))
2654         return false;
2655     impl.setEnumAttr(nativeValue.value());
2656     return true;
2657 }
2658
2659
2660 bool setJSTestObjByteAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2661 {
2662     JSValue value = JSValue::decode(encodedValue);
2663     UNUSED_PARAM(thisValue);
2664     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2665     if (UNLIKELY(!castedThis)) {
2666         return throwSetterTypeError(*state, "TestObj", "byteAttr");
2667     }
2668     auto& impl = castedThis->wrapped();
2669     auto nativeValue = toInt8(state, value, NormalConversion);
2670     if (UNLIKELY(state->hadException()))
2671         return false;
2672     impl.setByteAttr(WTFMove(nativeValue));
2673     return true;
2674 }
2675
2676
2677 bool setJSTestObjOctetAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2678 {
2679     JSValue value = JSValue::decode(encodedValue);
2680     UNUSED_PARAM(thisValue);
2681     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2682     if (UNLIKELY(!castedThis)) {
2683         return throwSetterTypeError(*state, "TestObj", "octetAttr");
2684     }
2685     auto& impl = castedThis->wrapped();
2686     auto nativeValue = toUInt8(state, value, NormalConversion);
2687     if (UNLIKELY(state->hadException()))
2688         return false;
2689     impl.setOctetAttr(WTFMove(nativeValue));
2690     return true;
2691 }
2692
2693
2694 bool setJSTestObjShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2695 {
2696     JSValue value = JSValue::decode(encodedValue);
2697     UNUSED_PARAM(thisValue);
2698     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2699     if (UNLIKELY(!castedThis)) {
2700         return throwSetterTypeError(*state, "TestObj", "shortAttr");
2701     }
2702     auto& impl = castedThis->wrapped();
2703     auto nativeValue = toInt16(state, value, NormalConversion);
2704     if (UNLIKELY(state->hadException()))
2705         return false;
2706     impl.setShortAttr(WTFMove(nativeValue));
2707     return true;
2708 }
2709
2710
2711 bool setJSTestObjClampedShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2712 {
2713     JSValue value = JSValue::decode(encodedValue);
2714     UNUSED_PARAM(thisValue);
2715     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2716     if (UNLIKELY(!castedThis)) {
2717         return throwSetterTypeError(*state, "TestObj", "clampedShortAttr");
2718     }
2719     auto& impl = castedThis->wrapped();
2720     auto nativeValue = toInt16(state, value, Clamp);
2721     if (UNLIKELY(state->hadException()))
2722         return false;
2723     impl.setClampedShortAttr(WTFMove(nativeValue));
2724     return true;
2725 }
2726
2727
2728 bool setJSTestObjEnforceRangeShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2729 {
2730     JSValue value = JSValue::decode(encodedValue);
2731     UNUSED_PARAM(thisValue);
2732     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2733     if (UNLIKELY(!castedThis)) {
2734         return throwSetterTypeError(*state, "TestObj", "enforceRangeShortAttr");
2735     }
2736     auto& impl = castedThis->wrapped();
2737     auto nativeValue = toInt16(state, value, EnforceRange);
2738     if (UNLIKELY(state->hadException()))
2739         return false;
2740     impl.setEnforceRangeShortAttr(WTFMove(nativeValue));
2741     return true;
2742 }
2743
2744
2745 bool setJSTestObjUnsignedShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2746 {
2747     JSValue value = JSValue::decode(encodedValue);
2748     UNUSED_PARAM(thisValue);
2749     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2750     if (UNLIKELY(!castedThis)) {
2751         return throwSetterTypeError(*state, "TestObj", "unsignedShortAttr");
2752     }
2753     auto& impl = castedThis->wrapped();
2754     auto nativeValue = toUInt16(state, value, NormalConversion);
2755     if (UNLIKELY(state->hadException()))
2756         return false;
2757     impl.setUnsignedShortAttr(WTFMove(nativeValue));
2758     return true;
2759 }
2760
2761
2762 bool setJSTestObjLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2763 {
2764     JSValue value = JSValue::decode(encodedValue);
2765     UNUSED_PARAM(thisValue);
2766     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2767     if (UNLIKELY(!castedThis)) {
2768         return throwSetterTypeError(*state, "TestObj", "longAttr");
2769     }
2770     auto& impl = castedThis->wrapped();
2771     auto nativeValue = toInt32(state, value, NormalConversion);
2772     if (UNLIKELY(state->hadException()))
2773         return false;
2774     impl.setLongAttr(WTFMove(nativeValue));
2775     return true;
2776 }
2777
2778
2779 bool setJSTestObjLongLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2780 {
2781     JSValue value = JSValue::decode(encodedValue);
2782     UNUSED_PARAM(thisValue);
2783     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2784     if (UNLIKELY(!castedThis)) {
2785         return throwSetterTypeError(*state, "TestObj", "longLongAttr");
2786     }
2787     auto& impl = castedThis->wrapped();
2788     auto nativeValue = toInt64(state, value, NormalConversion);
2789     if (UNLIKELY(state->hadException()))
2790         return false;
2791     impl.setLongLongAttr(WTFMove(nativeValue));
2792     return true;
2793 }
2794
2795
2796 bool setJSTestObjUnsignedLongLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2797 {
2798     JSValue value = JSValue::decode(encodedValue);
2799     UNUSED_PARAM(thisValue);
2800     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2801     if (UNLIKELY(!castedThis)) {
2802         return throwSetterTypeError(*state, "TestObj", "unsignedLongLongAttr");
2803     }
2804     auto& impl = castedThis->wrapped();
2805     auto nativeValue = toUInt64(state, value, NormalConversion);
2806     if (UNLIKELY(state->hadException()))
2807         return false;
2808     impl.setUnsignedLongLongAttr(WTFMove(nativeValue));
2809     return true;
2810 }
2811
2812
2813 bool setJSTestObjStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2814 {
2815     JSValue value = JSValue::decode(encodedValue);
2816     UNUSED_PARAM(thisValue);
2817     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2818     if (UNLIKELY(!castedThis)) {
2819         return throwSetterTypeError(*state, "TestObj", "stringAttr");
2820     }
2821     auto& impl = castedThis->wrapped();
2822     auto nativeValue = value.toWTFString(state);
2823     if (UNLIKELY(state->hadException()))
2824         return false;
2825     impl.setStringAttr(WTFMove(nativeValue));
2826     return true;
2827 }
2828
2829
2830 bool setJSTestObjTestObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2831 {
2832     JSValue value = JSValue::decode(encodedValue);
2833     UNUSED_PARAM(thisValue);
2834     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2835     if (UNLIKELY(!castedThis)) {
2836         return throwSetterTypeError(*state, "TestObj", "testObjAttr");
2837     }
2838     auto& impl = castedThis->wrapped();
2839     auto nativeValue = JSTestObj::toWrapped(value);
2840     if (UNLIKELY(!nativeValue)) {
2841         throwVMTypeError(state);
2842         return false;
2843     }
2844     impl.setTestObjAttr(*nativeValue);
2845     return true;
2846 }
2847
2848
2849 bool setJSTestObjTestNullableObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2850 {
2851     JSValue value = JSValue::decode(encodedValue);
2852     UNUSED_PARAM(thisValue);
2853     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2854     if (UNLIKELY(!castedThis)) {
2855         return throwSetterTypeError(*state, "TestObj", "testNullableObjAttr");
2856     }
2857     auto& impl = castedThis->wrapped();
2858     auto nativeValue = JSTestObj::toWrapped(value);
2859     impl.setTestNullableObjAttr(WTFMove(nativeValue));
2860     return true;
2861 }
2862
2863
2864 bool setJSTestObjLenientTestObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2865 {
2866     JSValue value = JSValue::decode(encodedValue);
2867     UNUSED_PARAM(thisValue);
2868     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2869     if (UNLIKELY(!castedThis)) {
2870         return false;
2871     }
2872     auto& impl = castedThis->wrapped();
2873     auto nativeValue = JSTestObj::toWrapped(value);
2874     if (UNLIKELY(!nativeValue)) {
2875         throwVMTypeError(state);
2876         return false;
2877     }
2878     impl.setLenientTestObjAttr(*nativeValue);
2879     return true;
2880 }
2881
2882
2883 bool setJSTestObjStringAttrTreatingNullAsEmptyString(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2884 {
2885     JSValue value = JSValue::decode(encodedValue);
2886     UNUSED_PARAM(thisValue);
2887     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2888     if (UNLIKELY(!castedThis)) {
2889         return throwSetterTypeError(*state, "TestObj", "stringAttrTreatingNullAsEmptyString");
2890     }
2891     auto& impl = castedThis->wrapped();
2892     auto nativeValue = valueToStringTreatingNullAsEmptyString(state, value);
2893     if (UNLIKELY(state->hadException()))
2894         return false;
2895     impl.setStringAttrTreatingNullAsEmptyString(WTFMove(nativeValue));
2896     return true;
2897 }
2898
2899
2900 bool setJSTestObjXMLObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2901 {
2902     JSValue value = JSValue::decode(encodedValue);
2903     UNUSED_PARAM(thisValue);
2904     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2905     if (UNLIKELY(!castedThis)) {
2906         return throwSetterTypeError(*state, "TestObj", "XMLObjAttr");
2907     }
2908     auto& impl = castedThis->wrapped();
2909     auto nativeValue = JSTestObj::toWrapped(value);
2910     if (UNLIKELY(!nativeValue)) {
2911         throwVMTypeError(state);
2912         return false;
2913     }
2914     impl.setXMLObjAttr(*nativeValue);
2915     return true;
2916 }
2917
2918
2919 bool setJSTestObjCreate(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2920 {
2921     JSValue value = JSValue::decode(encodedValue);
2922     UNUSED_PARAM(thisValue);
2923     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2924     if (UNLIKELY(!castedThis)) {
2925         return throwSetterTypeError(*state, "TestObj", "create");
2926     }
2927     auto& impl = castedThis->wrapped();
2928     auto nativeValue = value.toBoolean(state);
2929     if (UNLIKELY(state->hadException()))
2930         return false;
2931     impl.setCreate(WTFMove(nativeValue));
2932     return true;
2933 }
2934
2935
2936 bool setJSTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2937 {
2938     JSValue value = JSValue::decode(encodedValue);
2939     UNUSED_PARAM(thisValue);
2940     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2941     if (UNLIKELY(!castedThis)) {
2942         return throwSetterTypeError(*state, "TestObj", "reflectedStringAttr");
2943     }
2944     auto& impl = castedThis->wrapped();
2945     auto nativeValue = value.toWTFString(state);
2946     if (UNLIKELY(state->hadException()))
2947         return false;
2948     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedstringattrAttr, WTFMove(nativeValue));
2949     return true;
2950 }
2951
2952
2953 bool setJSTestObjReflectedIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2954 {
2955     JSValue value = JSValue::decode(encodedValue);
2956     UNUSED_PARAM(thisValue);
2957     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2958     if (UNLIKELY(!castedThis)) {
2959         return throwSetterTypeError(*state, "TestObj", "reflectedIntegralAttr");
2960     }
2961     auto& impl = castedThis->wrapped();
2962     auto nativeValue = toInt32(state, value, NormalConversion);
2963     if (UNLIKELY(state->hadException()))
2964         return false;
2965     impl.setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, WTFMove(nativeValue));
2966     return true;
2967 }
2968
2969
2970 bool setJSTestObjReflectedUnsignedIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2971 {
2972     JSValue value = JSValue::decode(encodedValue);
2973     UNUSED_PARAM(thisValue);
2974     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2975     if (UNLIKELY(!castedThis)) {
2976         return throwSetterTypeError(*state, "TestObj", "reflectedUnsignedIntegralAttr");
2977     }
2978     auto& impl = castedThis->wrapped();
2979     auto nativeValue = toUInt32(state, value, NormalConversion);
2980     if (UNLIKELY(state->hadException()))
2981         return false;
2982     impl.setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, WTFMove(nativeValue));
2983     return true;
2984 }
2985
2986
2987 bool setJSTestObjReflectedBooleanAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2988 {
2989     JSValue value = JSValue::decode(encodedValue);
2990     UNUSED_PARAM(thisValue);
2991     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2992     if (UNLIKELY(!castedThis)) {
2993         return throwSetterTypeError(*state, "TestObj", "reflectedBooleanAttr");
2994     }
2995     auto& impl = castedThis->wrapped();
2996     auto nativeValue = value.toBoolean(state);
2997     if (UNLIKELY(state->hadException()))
2998         return false;
2999     impl.setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, WTFMove(nativeValue));
3000     return true;
3001 }
3002
3003
3004 bool setJSTestObjReflectedURLAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3005 {
3006     JSValue value = JSValue::decode(encodedValue);
3007     UNUSED_PARAM(thisValue);
3008     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3009     if (UNLIKELY(!castedThis)) {
3010         return throwSetterTypeError(*state, "TestObj", "reflectedURLAttr");
3011     }
3012     auto& impl = castedThis->wrapped();
3013     auto nativeValue = value.toWTFString(state);
3014     if (UNLIKELY(state->hadException()))
3015         return false;
3016     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedurlattrAttr, WTFMove(nativeValue));
3017     return true;
3018 }
3019
3020
3021 bool setJSTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3022 {
3023     JSValue value = JSValue::decode(encodedValue);
3024     UNUSED_PARAM(thisValue);
3025     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3026     if (UNLIKELY(!castedThis)) {
3027         return throwSetterTypeError(*state, "TestObj", "reflectedStringAttr");
3028     }
3029     auto& impl = castedThis->wrapped();
3030     auto nativeValue = value.toWTFString(state);
3031     if (UNLIKELY(state->hadException()))
3032         return false;
3033     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentStringAttrAttr, WTFMove(nativeValue));
3034     return true;
3035 }
3036
3037
3038 bool setJSTestObjReflectedCustomIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3039 {
3040     JSValue value = JSValue::decode(encodedValue);
3041     UNUSED_PARAM(thisValue);
3042     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3043     if (UNLIKELY(!castedThis)) {
3044         return throwSetterTypeError(*state, "TestObj", "reflectedCustomIntegralAttr");
3045     }
3046     auto& impl = castedThis->wrapped();
3047     auto nativeValue = toInt32(state, value, NormalConversion);
3048     if (UNLIKELY(state->hadException()))
3049         return false;
3050     impl.setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, WTFMove(nativeValue));
3051     return true;
3052 }
3053
3054
3055 bool setJSTestObjReflectedCustomBooleanAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3056 {
3057     JSValue value = JSValue::decode(encodedValue);
3058     UNUSED_PARAM(thisValue);
3059     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3060     if (UNLIKELY(!castedThis)) {
3061         return throwSetterTypeError(*state, "TestObj", "reflectedCustomBooleanAttr");
3062     }
3063     auto& impl = castedThis->wrapped();
3064     auto nativeValue = value.toBoolean(state);
3065     if (UNLIKELY(state->hadException()))
3066         return false;
3067     impl.setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, WTFMove(nativeValue));
3068     return true;
3069 }
3070
3071
3072 bool setJSTestObjReflectedCustomURLAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3073 {
3074     JSValue value = JSValue::decode(encodedValue);
3075     UNUSED_PARAM(thisValue);
3076     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3077     if (UNLIKELY(!castedThis)) {
3078         return throwSetterTypeError(*state, "TestObj", "reflectedCustomURLAttr");
3079     }
3080     auto& impl = castedThis->wrapped();
3081     auto nativeValue = value.toWTFString(state);
3082     if (UNLIKELY(state->hadException()))
3083         return false;
3084     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentURLAttrAttr, WTFMove(nativeValue));
3085     return true;
3086 }
3087
3088
3089 #if ENABLE(TEST_FEATURE)
3090 bool setJSTestObjEnabledAtRuntimeAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3091 {
3092     JSValue value = JSValue::decode(encodedValue);
3093     UNUSED_PARAM(thisValue);
3094     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3095     if (UNLIKELY(!castedThis)) {
3096         return throwSetterTypeError(*state, "TestObj", "enabledAtRuntimeAttribute");
3097     }
3098     auto& impl = castedThis->wrapped();
3099     auto nativeValue = value.toWTFString(state);
3100     if (UNLIKELY(state->hadException()))
3101         return false;
3102     impl.setEnabledAtRuntimeAttribute(WTFMove(nativeValue));
3103     return true;
3104 }
3105
3106 #endif
3107
3108 bool setJSTestObjTypedArrayAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3109 {
3110     JSValue value = JSValue::decode(encodedValue);
3111     UNUSED_PARAM(thisValue);
3112     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3113     if (UNLIKELY(!castedThis)) {
3114         return throwSetterTypeError(*state, "TestObj", "typedArrayAttr");
3115     }
3116     auto& impl = castedThis->wrapped();
3117     auto nativeValue = toFloat32Array(value);
3118     if (UNLIKELY(state->hadException()))
3119         return false;
3120     if (UNLIKELY(!nativeValue)) {
3121         throwVMTypeError(state);
3122         return false;
3123     }
3124     impl.setTypedArrayAttr(nativeValue.get());
3125     return true;
3126 }
3127
3128
3129 bool setJSTestObjAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3130 {
3131     JSValue value = JSValue::decode(encodedValue);
3132     UNUSED_PARAM(thisValue);
3133     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3134     if (UNLIKELY(!castedThis)) {
3135         return throwSetterTypeError(*state, "TestObj", "attrWithGetterException");
3136     }
3137     auto& impl = castedThis->wrapped();
3138     auto nativeValue = toInt32(state, value, NormalConversion);
3139     if (UNLIKELY(state->hadException()))
3140         return false;
3141     impl.setAttrWithGetterException(WTFMove(nativeValue));
3142     return true;
3143 }
3144
3145
3146 bool setJSTestObjAttrWithGetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3147 {
3148     JSValue value = JSValue::decode(encodedValue);
3149     UNUSED_PARAM(thisValue);
3150     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3151     if (UNLIKELY(!castedThis)) {
3152         return throwSetterTypeError(*state, "TestObj", "attrWithGetterExceptionWithMessage");
3153     }
3154     auto& impl = castedThis->wrapped();
3155     auto nativeValue = toInt32(state, value, NormalConversion);
3156     if (UNLIKELY(state->hadException()))
3157         return false;
3158     impl.setAttrWithGetterExceptionWithMessage(WTFMove(nativeValue));
3159     return true;
3160 }
3161
3162
3163 bool setJSTestObjAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3164 {
3165     JSValue value = JSValue::decode(encodedValue);
3166     UNUSED_PARAM(thisValue);
3167     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3168     if (UNLIKELY(!castedThis)) {
3169         return throwSetterTypeError(*state, "TestObj", "attrWithSetterException");
3170     }
3171     auto& impl = castedThis->wrapped();
3172     ExceptionCode ec = 0;
3173     auto nativeValue = toInt32(state, value, NormalConversion);
3174     if (UNLIKELY(state->hadException()))
3175         return false;
3176     impl.setAttrWithSetterException(WTFMove(nativeValue), ec);
3177     setDOMException(state, ec);
3178     return true;
3179 }
3180
3181
3182 bool setJSTestObjAttrWithSetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3183 {
3184     JSValue value = JSValue::decode(encodedValue);
3185     UNUSED_PARAM(thisValue);
3186     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3187     if (UNLIKELY(!castedThis)) {
3188         return throwSetterTypeError(*state, "TestObj", "attrWithSetterExceptionWithMessage"