e6041b8cc6d42440f89e7837342413bb0049c841
[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 "JSDOMBuild.h"
33 #include "JSDOMConstructor.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 build<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 build<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 build<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 build<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 build<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 build<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 build<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 build<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 build<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 build<TestObj::ShadowRootInit>(ExecState& state, JSValue value)
487 {
488     return { 
489         build<TestObj::ShadowRootMode>(state, value, "mode"),
490     };
491 }
492
493 // Functions
494
495 #if ENABLE(TEST_FEATURE)
496 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionEnabledAtRuntimeOperation(JSC::ExecState*);
497 #endif
498 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(JSC::ExecState*);
499 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(JSC::ExecState*);
500 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethod(JSC::ExecState*);
501 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethodWithArgs(JSC::ExecState*);
502 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethod(JSC::ExecState*);
503 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethodWithArgs(JSC::ExecState*);
504 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(JSC::ExecState*);
505 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(JSC::ExecState*);
506 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(JSC::ExecState*);
507 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(JSC::ExecState*);
508 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjInstanceFunctionUnforgeableMethod(JSC::ExecState*);
509 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithArgTreatingNullAsEmptyString(JSC::ExecState*);
510 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionNullableStringMethod(JSC::ExecState*);
511 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionNullableStringStaticMethod(JSC::ExecState*);
512 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionNullableStringSpecialMethod(JSC::ExecState*);
513 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithSequenceArg(JSC::ExecState*);
514 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodReturningSequence(JSC::ExecState*);
515 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithEnumArg(JSC::ExecState*);
516 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalEnumArgAndDefaultValue(JSC::ExecState*);
517 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(JSC::ExecState*);
518 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(JSC::ExecState*);
519 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOptionsObject(JSC::ExecState*);
520 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(JSC::ExecState*);
521 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithExceptionWithMessage(JSC::ExecState*);
522 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(JSC::ExecState*);
523 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(JSC::ExecState*);
524 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionPrivateMethod(JSC::ExecState*);
525 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(JSC::ExecState*);
526 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(JSC::ExecState*);
527 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(JSC::ExecState*);
528 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(JSC::ExecState*);
529 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(JSC::ExecState*);
530 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(JSC::ExecState*);
531 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContext(JSC::ExecState*);
532 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState(JSC::ExecState*);
533 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException(JSC::ExecState*);
534 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces(JSC::ExecState*);
535 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack(JSC::ExecState*);
536 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDocumentArgument(JSC::ExecState*);
537 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(JSC::ExecState*);
538 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArgAndDefaultValue(JSC::ExecState*);
539 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(JSC::ExecState*);
540 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(JSC::ExecState*);
541 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalString(JSC::ExecState*);
542 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicString(JSC::ExecState*);
543 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue(JSC::ExecState*);
544 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue(JSC::ExecState*);
545 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull(JSC::ExecState*);
546 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined(JSC::ExecState*);
547 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull(JSC::ExecState*);
548 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString(JSC::ExecState*);
549 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString(JSC::ExecState*);
550 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN(JSC::ExecState*);
551 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN(JSC::ExecState*);
552 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalSequence(JSC::ExecState*);
553 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalLongLong(JSC::ExecState*);
554 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalLongLongIsZero(JSC::ExecState*);
555 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLong(JSC::ExecState*);
556 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLongIsZero(JSC::ExecState*);
557 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArray(JSC::ExecState*);
558 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArrayIsEmpty(JSC::ExecState*);
559 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalBoolean(JSC::ExecState*);
560 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalBooleanIsFalse(JSC::ExecState*);
561 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAny(JSC::ExecState*);
562 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapper(JSC::ExecState*);
563 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapperIsNull(JSC::ExecState*);
564 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackArg(JSC::ExecState*);
565 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg(JSC::ExecState*);
566 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg(JSC::ExecState*);
567 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackFunctionArg(JSC::ExecState*);
568 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackFunctionArg(JSC::ExecState*);
569 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackFunctionAndOptionalArg(JSC::ExecState*);
570 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg(JSC::ExecState*);
571 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionStaticMethodWithCallbackArg(JSC::ExecState*);
572 #if ENABLE(Condition1)
573 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod1(JSC::ExecState*);
574 #endif
575 #if ENABLE(Condition1) && ENABLE(Condition2)
576 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod2(JSC::ExecState*);
577 #endif
578 #if ENABLE(Condition1) || ENABLE(Condition2)
579 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod3(JSC::ExecState*);
580 #endif
581 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(JSC::ExecState*);
582 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethodWithOptionalParameter(JSC::ExecState*);
583 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethod(JSC::ExecState*);
584 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethodWithOptional(JSC::ExecState*);
585 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethod2(JSC::ExecState*);
586 #if ENABLE(Condition1)
587 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionOverloadedMethod1(JSC::ExecState*);
588 #endif
589 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionClassMethodWithClamp(JSC::ExecState*);
590 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionClassMethodWithEnforceRange(JSC::ExecState*);
591 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence(JSC::ExecState*);
592 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStringArrayFunction(JSC::ExecState*);
593 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionDomStringListFunction(JSC::ExecState*);
594 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence(JSC::ExecState*);
595 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence2(JSC::ExecState*);
596 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionGetSVGDocument(JSC::ExecState*);
597 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert1(JSC::ExecState*);
598 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert2(JSC::ExecState*);
599 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert3(JSC::ExecState*);
600 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert4(JSC::ExecState*);
601 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMutablePointFunction(JSC::ExecState*);
602 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionImmutablePointFunction(JSC::ExecState*);
603 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOrange(JSC::ExecState*);
604 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunction(JSC::ExecState*);
605 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithSequence(JSC::ExecState*);
606 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithArray(JSC::ExecState*);
607 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicStringMethod(JSC::ExecState*);
608 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicDoubleMethod(JSC::ExecState*);
609 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicNodeMethod(JSC::ExecState*);
610 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAny(JSC::ExecState*);
611 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(JSC::ExecState*);
612 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(JSC::ExecState*);
613 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(JSC::ExecState*);
614 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(JSC::ExecState*);
615 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunction(JSC::ExecState*);
616 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(JSC::ExecState*);
617 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(JSC::ExecState*);
618 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNeedsLifecycleProcessingStack(JSC::ExecState*);
619 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAttachShadowRoot(JSC::ExecState*);
620 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSymbolIterator(JSC::ExecState*);
621 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionEntries(JSC::ExecState*);
622 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionKeys(JSC::ExecState*);
623 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionValues(JSC::ExecState*);
624 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionForEach(JSC::ExecState*);
625
626 // Attributes
627
628 JSC::EncodedJSValue jsTestObjReadOnlyLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
629 JSC::EncodedJSValue jsTestObjReadOnlyStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
630 JSC::EncodedJSValue jsTestObjReadOnlyTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
631 JSC::EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
632 JSC::EncodedJSValue jsTestObjConstructorStaticStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
633 bool setJSTestObjConstructorStaticStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
634 JSC::EncodedJSValue jsTestObjConstructorTestSubObj(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
635 JSC::EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
636 bool setJSTestObjTestSubObjEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
637 JSC::EncodedJSValue jsTestObjEnumAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
638 bool setJSTestObjEnumAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
639 JSC::EncodedJSValue jsTestObjByteAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
640 bool setJSTestObjByteAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
641 JSC::EncodedJSValue jsTestObjOctetAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
642 bool setJSTestObjOctetAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
643 JSC::EncodedJSValue jsTestObjShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
644 bool setJSTestObjShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
645 JSC::EncodedJSValue jsTestObjClampedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
646 bool setJSTestObjClampedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
647 JSC::EncodedJSValue jsTestObjEnforceRangeShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
648 bool setJSTestObjEnforceRangeShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
649 JSC::EncodedJSValue jsTestObjUnsignedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
650 bool setJSTestObjUnsignedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
651 JSC::EncodedJSValue jsTestObjLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
652 bool setJSTestObjLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
653 JSC::EncodedJSValue jsTestObjLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
654 bool setJSTestObjLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
655 JSC::EncodedJSValue jsTestObjUnsignedLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
656 bool setJSTestObjUnsignedLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
657 JSC::EncodedJSValue jsTestObjStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
658 bool setJSTestObjStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
659 JSC::EncodedJSValue jsTestObjTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
660 bool setJSTestObjTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
661 JSC::EncodedJSValue jsTestObjTestNullableObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
662 bool setJSTestObjTestNullableObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
663 JSC::EncodedJSValue jsTestObjLenientTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
664 bool setJSTestObjLenientTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
665 JSC::EncodedJSValue jsTestObjUnforgeableAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
666 JSC::EncodedJSValue jsTestObjStringAttrTreatingNullAsEmptyString(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
667 bool setJSTestObjStringAttrTreatingNullAsEmptyString(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
668 JSC::EncodedJSValue jsTestObjXMLObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
669 bool setJSTestObjXMLObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
670 JSC::EncodedJSValue jsTestObjCreate(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
671 bool setJSTestObjCreate(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
672 JSC::EncodedJSValue jsTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
673 bool setJSTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
674 JSC::EncodedJSValue jsTestObjReflectedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
675 bool setJSTestObjReflectedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
676 JSC::EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
677 bool setJSTestObjReflectedUnsignedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
678 JSC::EncodedJSValue jsTestObjReflectedBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
679 bool setJSTestObjReflectedBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
680 JSC::EncodedJSValue jsTestObjReflectedURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
681 bool setJSTestObjReflectedURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
682 JSC::EncodedJSValue jsTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
683 bool setJSTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
684 JSC::EncodedJSValue jsTestObjReflectedCustomIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
685 bool setJSTestObjReflectedCustomIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
686 JSC::EncodedJSValue jsTestObjReflectedCustomBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
687 bool setJSTestObjReflectedCustomBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
688 JSC::EncodedJSValue jsTestObjReflectedCustomURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
689 bool setJSTestObjReflectedCustomURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
690 #if ENABLE(TEST_FEATURE)
691 JSC::EncodedJSValue jsTestObjEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
692 bool setJSTestObjEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
693 #endif
694 JSC::EncodedJSValue jsTestObjTypedArrayAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
695 bool setJSTestObjTypedArrayAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
696 JSC::EncodedJSValue jsTestObjAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
697 bool setJSTestObjAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
698 JSC::EncodedJSValue jsTestObjAttrWithGetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
699 bool setJSTestObjAttrWithGetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
700 JSC::EncodedJSValue jsTestObjAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
701 bool setJSTestObjAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
702 JSC::EncodedJSValue jsTestObjAttrWithSetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
703 bool setJSTestObjAttrWithSetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
704 JSC::EncodedJSValue jsTestObjStringAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
705 bool setJSTestObjStringAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
706 JSC::EncodedJSValue jsTestObjStringAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
707 bool setJSTestObjStringAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
708 JSC::EncodedJSValue jsTestObjStrictTypeCheckingAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
709 bool setJSTestObjStrictTypeCheckingAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
710 JSC::EncodedJSValue jsTestObjCustomAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
711 bool setJSTestObjCustomAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
712 JSC::EncodedJSValue jsTestObjOnfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
713 bool setJSTestObjOnfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
714 JSC::EncodedJSValue jsTestObjOnwebkitfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
715 bool setJSTestObjOnwebkitfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
716 JSC::EncodedJSValue jsTestObjWithScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
717 bool setJSTestObjWithScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
718 JSC::EncodedJSValue jsTestObjWithCallWithAndSetterCallWithAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
719 bool setJSTestObjWithCallWithAndSetterCallWithAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
720 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
721 bool setJSTestObjWithScriptExecutionContextAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
722 JSC::EncodedJSValue jsTestObjWithScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
723 bool setJSTestObjWithScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
724 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
725 bool setJSTestObjWithScriptExecutionContextAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
726 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
727 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
728 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
729 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
730 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
731 bool setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
732 JSC::EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
733 bool setJSTestObjWithScriptArgumentsAndCallStackAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
734 #if ENABLE(Condition1)
735 JSC::EncodedJSValue jsTestObjConditionalAttr1(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
736 bool setJSTestObjConditionalAttr1(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
737 #endif
738 #if ENABLE(Condition1) && ENABLE(Condition2)
739 JSC::EncodedJSValue jsTestObjConditionalAttr2(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
740 bool setJSTestObjConditionalAttr2(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
741 #endif
742 #if ENABLE(Condition1) || ENABLE(Condition2)
743 JSC::EncodedJSValue jsTestObjConditionalAttr3(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
744 bool setJSTestObjConditionalAttr3(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
745 #endif
746 #if ENABLE(Condition1)
747 JSC::EncodedJSValue jsTestObjConditionalAttr4Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
748 bool setJSTestObjConditionalAttr4Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
749 #endif
750 #if ENABLE(Condition1) && ENABLE(Condition2)
751 JSC::EncodedJSValue jsTestObjConditionalAttr5Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
752 bool setJSTestObjConditionalAttr5Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
753 #endif
754 #if ENABLE(Condition1) || ENABLE(Condition2)
755 JSC::EncodedJSValue jsTestObjConditionalAttr6Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
756 bool setJSTestObjConditionalAttr6Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
757 #endif
758 JSC::EncodedJSValue jsTestObjCachedAttribute1(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
759 JSC::EncodedJSValue jsTestObjCachedAttribute2(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
760 JSC::EncodedJSValue jsTestObjAnyAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
761 bool setJSTestObjAnyAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
762 JSC::EncodedJSValue jsTestObjContentDocument(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
763 JSC::EncodedJSValue jsTestObjMutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
764 bool setJSTestObjMutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
765 JSC::EncodedJSValue jsTestObjImmutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
766 bool setJSTestObjImmutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
767 JSC::EncodedJSValue jsTestObjStrawberry(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
768 bool setJSTestObjStrawberry(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
769 JSC::EncodedJSValue jsTestObjStrictFloat(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
770 bool setJSTestObjStrictFloat(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
771 JSC::EncodedJSValue jsTestObjDescription(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
772 JSC::EncodedJSValue jsTestObjId(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
773 bool setJSTestObjId(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
774 JSC::EncodedJSValue jsTestObjHash(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
775 JSC::EncodedJSValue jsTestObjReplaceableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
776 bool setJSTestObjReplaceableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
777 JSC::EncodedJSValue jsTestObjNullableDoubleAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
778 JSC::EncodedJSValue jsTestObjNullableLongAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
779 JSC::EncodedJSValue jsTestObjNullableBooleanAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
780 JSC::EncodedJSValue jsTestObjNullableStringAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
781 JSC::EncodedJSValue jsTestObjNullableLongSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
782 bool setJSTestObjNullableLongSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
783 JSC::EncodedJSValue jsTestObjNullableStringSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
784 bool setJSTestObjNullableStringSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
785 JSC::EncodedJSValue jsTestObjNullableStringValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
786 bool setJSTestObjNullableStringValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
787 JSC::EncodedJSValue jsTestObjAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
788 JSC::EncodedJSValue jsTestObjAttributeWithReservedEnumType(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
789 bool setJSTestObjAttributeWithReservedEnumType(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
790 JSC::EncodedJSValue jsTestObjPutForwardsAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
791 bool setJSTestObjPutForwardsAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
792 JSC::EncodedJSValue jsTestObjPutForwardsNullableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
793 bool setJSTestObjPutForwardsNullableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
794 JSC::EncodedJSValue jsTestObjConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
795 bool setJSTestObjConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
796
797 class JSTestObjPrototype : public JSC::JSNonFinalObject {
798 public:
799     typedef JSC::JSNonFinalObject Base;
800     static JSTestObjPrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
801     {
802         JSTestObjPrototype* ptr = new (NotNull, JSC::allocateCell<JSTestObjPrototype>(vm.heap)) JSTestObjPrototype(vm, globalObject, structure);
803         ptr->finishCreation(vm);
804         return ptr;
805     }
806
807     DECLARE_INFO;
808     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
809     {
810         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
811     }
812
813 private:
814     JSTestObjPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
815         : JSC::JSNonFinalObject(vm, structure)
816     {
817     }
818
819     void finishCreation(JSC::VM&);
820 };
821
822 typedef JSDOMConstructor<JSTestObj> JSTestObjConstructor;
823
824 /* Hash table */
825
826 static const struct CompactHashIndex JSTestObjTableIndex[17] = {
827     { -1, -1 },
828     { -1, -1 },
829     { 5, -1 },
830     { -1, -1 },
831     { -1, -1 },
832     { -1, -1 },
833     { 4, -1 },
834     { -1, -1 },
835     { 1, -1 },
836     { 2, -1 },
837     { 0, 16 },
838     { -1, -1 },
839     { -1, -1 },
840     { -1, -1 },
841     { -1, -1 },
842     { -1, -1 },
843     { 3, -1 },
844 };
845
846
847 static const HashTableValue JSTestObjTableValues[] =
848 {
849     { "TestSubObjEnabledBySetting", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestSubObjEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestSubObjEnabledBySettingConstructor) } },
850     { "unforgeableAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnforgeableAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
851 #if ENABLE(Condition1)
852     { "conditionalAttr4", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr4Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr4Constructor) } },
853 #else
854     { 0, 0, NoIntrinsic, { 0, 0 } },
855 #endif
856 #if ENABLE(Condition1) && ENABLE(Condition2)
857     { "conditionalAttr5", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr5Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr5Constructor) } },
858 #else
859     { 0, 0, NoIntrinsic, { 0, 0 } },
860 #endif
861 #if ENABLE(Condition1) || ENABLE(Condition2)
862     { "conditionalAttr6", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr6Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr6Constructor) } },
863 #else
864     { 0, 0, NoIntrinsic, { 0, 0 } },
865 #endif
866     { "unforgeableMethod", DontDelete | ReadOnly | JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjInstanceFunctionUnforgeableMethod), (intptr_t) (0) } },
867 };
868
869 static const HashTable JSTestObjTable = { 6, 15, true, JSTestObjTableValues, JSTestObjTableIndex };
870 /* Hash table for constructor */
871
872 static const HashTableValue JSTestObjConstructorTableValues[] =
873 {
874 #if ENABLE(Condition1)
875     { "CONDITIONAL_CONST", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
876 #else
877     { 0, 0, NoIntrinsic, { 0, 0 } },
878 #endif
879     { "CONST_VALUE_0", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
880     { "CONST_VALUE_1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
881     { "CONST_VALUE_2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
882     { "CONST_VALUE_4", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(4) } },
883     { "CONST_VALUE_8", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(8) } },
884     { "CONST_VALUE_9", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(-1) } },
885     { "CONST_VALUE_11", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0xffffffff) } },
886     { "CONST_VALUE_12", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x01) } },
887     { "CONST_VALUE_13", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0X20) } },
888     { "CONST_VALUE_14", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x1abc) } },
889     { "CONST_JAVASCRIPT", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(15) } },
890     { "readonly", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
891     { "staticReadOnlyLongAttr", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
892     { "staticStringAttr", DontDelete, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructorStaticStringAttr) } },
893     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
894     { "nullableStringStaticMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionNullableStringStaticMethod), (intptr_t) (0) } },
895     { "staticMethodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg), (intptr_t) (0) } },
896     { "staticMethodWithCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackArg), (intptr_t) (1) } },
897     { "classMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod), (intptr_t) (0) } },
898     { "classMethodWithOptional", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethodWithOptional), (intptr_t) (0) } },
899     { "classMethod2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod2), (intptr_t) (1) } },
900 #if ENABLE(Condition1)
901     { "overloadedMethod1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionOverloadedMethod1), (intptr_t) (1) } },
902 #else
903     { 0, 0, NoIntrinsic, { 0, 0 } },
904 #endif
905     { "testStaticPromiseFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionTestStaticPromiseFunction), (intptr_t) (0) } },
906     { "testStaticPromiseFunctionWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException), (intptr_t) (0) } },
907 };
908
909 #if ENABLE(Condition1)
910 static_assert(TestObj::CONDITIONAL_CONST == 0, "CONDITIONAL_CONST in TestObj does not match value from IDL");
911 #endif
912 static_assert(TestObj::CONST_VALUE_0 == 0, "CONST_VALUE_0 in TestObj does not match value from IDL");
913 static_assert(TestObj::CONST_VALUE_1 == 1, "CONST_VALUE_1 in TestObj does not match value from IDL");
914 static_assert(TestObj::CONST_VALUE_2 == 2, "CONST_VALUE_2 in TestObj does not match value from IDL");
915 static_assert(TestObj::CONST_VALUE_4 == 4, "CONST_VALUE_4 in TestObj does not match value from IDL");
916 static_assert(TestObj::CONST_VALUE_8 == 8, "CONST_VALUE_8 in TestObj does not match value from IDL");
917 static_assert(TestObj::CONST_VALUE_9 == -1, "CONST_VALUE_9 in TestObj does not match value from IDL");
918 static_assert(TestObj::CONST_VALUE_11 == 0xffffffff, "CONST_VALUE_11 in TestObj does not match value from IDL");
919 static_assert(TestObj::CONST_VALUE_12 == 0x01, "CONST_VALUE_12 in TestObj does not match value from IDL");
920 static_assert(TestObj::CONST_VALUE_13 == 0X20, "CONST_VALUE_13 in TestObj does not match value from IDL");
921 static_assert(TestObj::CONST_VALUE_14 == 0x1abc, "CONST_VALUE_14 in TestObj does not match value from IDL");
922 static_assert(TestObj::CONST_IMPL == 15, "CONST_IMPL in TestObj does not match value from IDL");
923 static_assert(TestObj::readonly == 0, "readonly in TestObj does not match value from IDL");
924
925 template<> EncodedJSValue JSC_HOST_CALL JSTestObjConstructor::construct(ExecState* state)
926 {
927     auto* castedThis = jsCast<JSTestObjConstructor*>(state->callee());
928     if (UNLIKELY(state->argumentCount() < 2))
929         return throwVMError(state, createNotEnoughArgumentsError(state));
930     if (UNLIKELY(!state->argument(0).isObject()))
931         return throwArgumentMustBeFunctionError(*state, 0, "testCallback", "TestObj", nullptr);
932     RefPtr<TestCallback> testCallback = JSTestCallback::create(asObject(state->uncheckedArgument(0)), castedThis->globalObject());
933     if (UNLIKELY(!state->argument(1).isFunction()))
934         return throwArgumentMustBeFunctionError(*state, 1, "testCallbackFunction", "TestObj", nullptr);
935     RefPtr<TestCallbackFunction> testCallbackFunction = JSTestCallbackFunction::create(asObject(state->uncheckedArgument(1)), castedThis->globalObject());
936     RefPtr<TestObj> object = TestObj::create(*testCallback, *testCallbackFunction);
937     return JSValue::encode(asObject(toJS(state, castedThis->globalObject(), object.get())));
938 }
939
940 template<> JSValue JSTestObjConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
941 {
942     UNUSED_PARAM(vm);
943     return globalObject.functionPrototype();
944 }
945
946 template<> void JSTestObjConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
947 {
948     putDirect(vm, vm.propertyNames->prototype, JSTestObj::prototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
949     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestObject"))), ReadOnly | DontEnum);
950     putDirect(vm, vm.propertyNames->length, jsNumber(2), ReadOnly | DontEnum);
951     reifyStaticProperties(vm, JSTestObjConstructorTableValues, *this);
952 }
953
954 template<> const ClassInfo JSTestObjConstructor::s_info = { "TestObject", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestObjConstructor) };
955
956 /* Hash table for prototype */
957
958 static const HashTableValue JSTestObjPrototypeTableValues[] =
959 {
960     { "constructor", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructor) } },
961     { "readOnlyLongAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
962     { "readOnlyStringAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
963     { "readOnlyTestObjAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
964     { "enumAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnumAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnumAttr) } },
965     { "byteAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjByteAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjByteAttr) } },
966     { "octetAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOctetAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOctetAttr) } },
967     { "shortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjShortAttr) } },
968     { "clampedShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjClampedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjClampedShortAttr) } },
969     { "enforceRangeShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnforceRangeShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnforceRangeShortAttr) } },
970     { "unsignedShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedShortAttr) } },
971     { "longAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongAttr) } },
972     { "longLongAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongLongAttr) } },
973     { "unsignedLongLongAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedLongLongAttr) } },
974     { "stringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttr) } },
975     { "testObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestObjAttr) } },
976     { "testNullableObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestNullableObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestNullableObjAttr) } },
977     { "lenientTestObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLenientTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLenientTestObjAttr) } },
978     { "stringAttrTreatingNullAsEmptyString", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrTreatingNullAsEmptyString), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrTreatingNullAsEmptyString) } },
979     { "XMLObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjXMLObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjXMLObjAttr) } },
980     { "create", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCreate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCreate) } },
981     { "reflectedStringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) } },
982     { "reflectedIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedIntegralAttr) } },
983     { "reflectedUnsignedIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedUnsignedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedUnsignedIntegralAttr) } },
984     { "reflectedBooleanAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedBooleanAttr) } },
985     { "reflectedURLAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedURLAttr) } },
986     { "reflectedStringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) } },
987     { "reflectedCustomIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomIntegralAttr) } },
988     { "reflectedCustomBooleanAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomBooleanAttr) } },
989     { "reflectedCustomURLAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomURLAttr) } },
990 #if ENABLE(TEST_FEATURE)
991     { "enabledAtRuntimeAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnabledAtRuntimeAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnabledAtRuntimeAttribute) } },
992 #else
993     { 0, 0, NoIntrinsic, { 0, 0 } },
994 #endif
995     { "typedArrayAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTypedArrayAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTypedArrayAttr) } },
996     { "attrWithGetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterException) } },
997     { "attrWithGetterExceptionWithMessage", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterExceptionWithMessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterExceptionWithMessage) } },
998     { "attrWithSetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterException) } },
999     { "attrWithSetterExceptionWithMessage", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterExceptionWithMessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterExceptionWithMessage) } },
1000     { "stringAttrWithGetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithGetterException) } },
1001     { "stringAttrWithSetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithSetterException) } },
1002     { "strictTypeCheckingAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictTypeCheckingAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictTypeCheckingAttribute) } },
1003     { "customAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCustomAttr) } },
1004 #if ENABLE(Condition4)
1005     { "jsBuiltinAttribute", Accessor | Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinAttributeCodeGenerator), (intptr_t) (setTestObjJsBuiltinAttributeCodeGenerator) } },
1006 #else
1007     { 0, 0, NoIntrinsic, { 0, 0 } },
1008 #endif
1009 #if ENABLE(Condition4)
1010     { "jsBuiltinReadOnlyAttribute", ReadOnly | Accessor | Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinReadOnlyAttributeCodeGenerator), (intptr_t) (0) } },
1011 #else
1012     { 0, 0, NoIntrinsic, { 0, 0 } },
1013 #endif
1014     { "onfoo", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOnfoo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOnfoo) } },
1015     { "onwebkitfoo", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOnwebkitfoo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOnwebkitfoo) } },
1016     { "withScriptStateAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttribute) } },
1017     { "withCallWithAndSetterCallWithAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithCallWithAndSetterCallWithAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithCallWithAndSetterCallWithAttribute) } },
1018     { "withScriptExecutionContextAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttribute) } },
1019     { "withScriptStateAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttributeRaises) } },
1020     { "withScriptExecutionContextAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttributeRaises) } },
1021     { "withScriptExecutionContextAndScriptStateAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttribute) } },
1022     { "withScriptExecutionContextAndScriptStateAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises) } },
1023     { "withScriptExecutionContextAndScriptStateWithSpacesAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute) } },
1024     { "withScriptArgumentsAndCallStackAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) } },
1025 #if ENABLE(Condition1)
1026     { "conditionalAttr1", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) } },
1027 #else
1028     { 0, 0, NoIntrinsic, { 0, 0 } },
1029 #endif
1030 #if ENABLE(Condition1) && ENABLE(Condition2)
1031     { "conditionalAttr2", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) } },
1032 #else
1033     { 0, 0, NoIntrinsic, { 0, 0 } },
1034 #endif
1035 #if ENABLE(Condition1) || ENABLE(Condition2)
1036     { "conditionalAttr3", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) } },
1037 #else
1038     { 0, 0, NoIntrinsic, { 0, 0 } },
1039 #endif
1040     { "cachedAttribute1", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1041     { "cachedAttribute2", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1042     { "anyAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAnyAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAnyAttribute) } },
1043     { "contentDocument", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjContentDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1044     { "mutablePoint", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjMutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjMutablePoint) } },
1045     { "immutablePoint", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjImmutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjImmutablePoint) } },
1046     { "strawberry", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrawberry), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrawberry) } },
1047     { "strictFloat", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictFloat), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictFloat) } },
1048     { "description", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDescription), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1049     { "id", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjId), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjId) } },
1050     { "hash", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjHash), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1051     { "replaceableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReplaceableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReplaceableAttribute) } },
1052     { "nullableDoubleAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableDoubleAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1053     { "nullableLongAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1054     { "nullableBooleanAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableBooleanAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1055     { "nullableStringAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1056     { "nullableLongSettableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableLongSettableAttribute) } },
1057     { "nullableStringSettableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringSettableAttribute) } },
1058     { "nullableStringValue", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringValue) } },
1059     { "attribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
1060     { "attributeWithReservedEnumType", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) } },
1061     { "putForwardsAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsAttribute) } },
1062     { "putForwardsNullableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsNullableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsNullableAttribute) } },
1063 #if ENABLE(TEST_FEATURE)
1064     { "enabledAtRuntimeOperation", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionEnabledAtRuntimeOperation), (intptr_t) (1) } },
1065 #else
1066     { 0, 0, NoIntrinsic, { 0, 0 } },
1067 #endif
1068     { "voidMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t) (0) } },
1069     { "voidMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t) (3) } },
1070     { "byteMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethod), (intptr_t) (0) } },
1071     { "byteMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethodWithArgs), (intptr_t) (3) } },
1072     { "octetMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethod), (intptr_t) (0) } },
1073     { "octetMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethodWithArgs), (intptr_t) (3) } },
1074     { "longMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethod), (intptr_t) (0) } },
1075     { "longMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethodWithArgs), (intptr_t) (3) } },
1076     { "objMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethod), (intptr_t) (0) } },
1077     { "objMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethodWithArgs), (intptr_t) (3) } },
1078     { "methodWithArgTreatingNullAsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithArgTreatingNullAsEmptyString), (intptr_t) (1) } },
1079     { "nullableStringMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionNullableStringMethod), (intptr_t) (0) } },
1080     { "nullableStringSpecialMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionNullableStringSpecialMethod), (intptr_t) (1) } },
1081     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) } },
1082     { "methodReturningSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodReturningSequence), (intptr_t) (1) } },
1083     { "methodWithEnumArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithEnumArg), (intptr_t) (1) } },
1084     { "methodWithOptionalEnumArgAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalEnumArgAndDefaultValue), (intptr_t) (0) } },
1085     { "methodThatRequiresAllArgsAndThrows", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows), (intptr_t) (2) } },
1086     { "serializedValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionSerializedValue), (intptr_t) (1) } },
1087     { "optionsObject", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOptionsObject), (intptr_t) (1) } },
1088     { "methodWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithException), (intptr_t) (0) } },
1089     { "methodWithExceptionWithMessage", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithExceptionWithMessage), (intptr_t) (0) } },
1090     { "customMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethod), (intptr_t) (0) } },
1091     { "customMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethodWithArgs), (intptr_t) (3) } },
1092 #if ENABLE(Condition3)
1093     { "jsBuiltinMethod", JSC::Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinMethodCodeGenerator), (intptr_t) (0) } },
1094 #else
1095     { 0, 0, NoIntrinsic, { 0, 0 } },
1096 #endif
1097 #if ENABLE(Condition3)
1098     { "jsBuiltinMethodWithArgs", JSC::Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinMethodWithArgsCodeGenerator), (intptr_t) (3) } },
1099 #else
1100     { 0, 0, NoIntrinsic, { 0, 0 } },
1101 #endif
1102     { "addEventListener", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAddEventListener), (intptr_t) (2) } },
1103     { "removeEventListener", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionRemoveEventListener), (intptr_t) (2) } },
1104     { "withScriptStateVoid", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoid), (intptr_t) (0) } },
1105     { "withScriptStateObj", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObj), (intptr_t) (0) } },
1106     { "withScriptStateVoidException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoidException), (intptr_t) (0) } },
1107     { "withScriptStateObjException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObjException), (intptr_t) (0) } },
1108     { "withScriptExecutionContext", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContext), (intptr_t) (0) } },
1109     { "withScriptExecutionContextAndScriptState", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState), (intptr_t) (0) } },
1110     { "withScriptExecutionContextAndScriptStateObjException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException), (intptr_t) (0) } },
1111     { "withScriptExecutionContextAndScriptStateWithSpaces", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces), (intptr_t) (0) } },
1112     { "withScriptArgumentsAndCallStack", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack), (intptr_t) (0) } },
1113     { "withDocumentArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithDocumentArgument), (intptr_t) (0) } },
1114     { "methodWithOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArg), (intptr_t) (0) } },
1115     { "methodWithOptionalArgAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArgAndDefaultValue), (intptr_t) (0) } },
1116     { "methodWithNonOptionalArgAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg), (intptr_t) (1) } },
1117     { "methodWithNonOptionalArgAndTwoOptionalArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs), (intptr_t) (1) } },
1118     { "methodWithOptionalString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalString), (intptr_t) (0) } },
1119     { "methodWithOptionalAtomicString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicString), (intptr_t) (0) } },
1120     { "methodWithOptionalStringAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue), (intptr_t) (0) } },
1121     { "methodWithOptionalAtomicStringAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue), (intptr_t) (0) } },
1122     { "methodWithOptionalStringIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull), (intptr_t) (0) } },
1123     { "methodWithOptionalStringIsUndefined", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined), (intptr_t) (0) } },
1124     { "methodWithOptionalAtomicStringIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull), (intptr_t) (0) } },
1125     { "methodWithOptionalStringIsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString), (intptr_t) (0) } },
1126     { "methodWithOptionalAtomicStringIsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString), (intptr_t) (0) } },
1127     { "methodWithOptionalDoubleIsNaN", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN), (intptr_t) (0) } },
1128     { "methodWithOptionalFloatIsNaN", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN), (intptr_t) (0) } },
1129     { "methodWithOptionalSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalSequence), (intptr_t) (0) } },
1130     { "methodWithOptionalLongLong", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalLongLong), (intptr_t) (0) } },
1131     { "methodWithOptionalLongLongIsZero", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalLongLongIsZero), (intptr_t) (0) } },
1132     { "methodWithOptionalUnsignedLongLong", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLong), (intptr_t) (0) } },
1133     { "methodWithOptionalUnsignedLongLongIsZero", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLongIsZero), (intptr_t) (0) } },
1134     { "methodWithOptionalArray", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArray), (intptr_t) (0) } },
1135     { "methodWithOptionalArrayIsEmpty", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArrayIsEmpty), (intptr_t) (0) } },
1136     { "methodWithOptionalBoolean", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalBoolean), (intptr_t) (0) } },
1137     { "methodWithOptionalBooleanIsFalse", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalBooleanIsFalse), (intptr_t) (0) } },
1138     { "methodWithOptionalAny", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAny), (intptr_t) (0) } },
1139     { "methodWithOptionalNullableWrapper", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapper), (intptr_t) (0) } },
1140     { "methodWithOptionalNullableWrapperIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapperIsNull), (intptr_t) (0) } },
1141     { "methodWithCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackArg), (intptr_t) (1) } },
1142     { "methodWithNonCallbackArgAndCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg), (intptr_t) (2) } },
1143     { "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) } },
1144     { "methodWithCallbackFunctionArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackFunctionArg), (intptr_t) (1) } },
1145     { "methodWithNonCallbackArgAndCallbackFunctionArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackFunctionArg), (intptr_t) (2) } },
1146     { "methodWithCallbackFunctionAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackFunctionAndOptionalArg), (intptr_t) (0) } },
1147 #if ENABLE(Condition1)
1148     { "conditionalMethod1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) } },
1149 #else
1150     { 0, 0, NoIntrinsic, { 0, 0 } },
1151 #endif
1152 #if ENABLE(Condition1) && ENABLE(Condition2)
1153     { "conditionalMethod2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) } },
1154 #else
1155     { 0, 0, NoIntrinsic, { 0, 0 } },
1156 #endif
1157 #if ENABLE(Condition1) || ENABLE(Condition2)
1158     { "conditionalMethod3", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) } },
1159 #else
1160     { 0, 0, NoIntrinsic, { 0, 0 } },
1161 #endif
1162     { "overloadedMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) } },
1163     { "overloadedMethodWithOptionalParameter", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethodWithOptionalParameter), (intptr_t) (1) } },
1164     { "classMethodWithClamp", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) } },
1165     { "classMethodWithEnforceRange", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithEnforceRange), (intptr_t) (2) } },
1166     { "methodWithUnsignedLongSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence), (intptr_t) (1) } },
1167     { "stringArrayFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStringArrayFunction), (intptr_t) (1) } },
1168     { "domStringListFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionDomStringListFunction), (intptr_t) (1) } },
1169     { "methodWithAndWithoutNullableSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence), (intptr_t) (2) } },
1170     { "methodWithAndWithoutNullableSequence2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence2), (intptr_t) (2) } },
1171     { "getSVGDocument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionGetSVGDocument), (intptr_t) (0) } },
1172     { "convert1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert1), (intptr_t) (1) } },
1173     { "convert2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert2), (intptr_t) (1) } },
1174     { "convert3", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert3), (intptr_t) (1) } },
1175     { "convert4", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert4), (intptr_t) (1) } },
1176     { "mutablePointFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMutablePointFunction), (intptr_t) (0) } },
1177     { "immutablePointFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionImmutablePointFunction), (intptr_t) (0) } },
1178     { "orange", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOrange), (intptr_t) (0) } },
1179     { "strictFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunction), (intptr_t) (3) } },
1180     { "strictFunctionWithSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithSequence), (intptr_t) (2) } },
1181     { "strictFunctionWithArray", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithArray), (intptr_t) (2) } },
1182     { "variadicStringMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicStringMethod), (intptr_t) (1) } },
1183     { "variadicDoubleMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (1) } },
1184     { "variadicNodeMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (1) } },
1185     { "any", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) } },
1186     { "testPromiseFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunction), (intptr_t) (0) } },
1187     { "testPromiseFunctionWithFloatArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument), (intptr_t) (1) } },
1188     { "testPromiseFunctionWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithException), (intptr_t) (0) } },
1189     { "testPromiseFunctionWithOptionalIntArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument), (intptr_t) (0) } },
1190     { "testPromiseOverloadedFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseOverloadedFunction), (intptr_t) (1) } },
1191     { "methodWithNeedsLifecycleProcessingStack", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNeedsLifecycleProcessingStack), (intptr_t) (0) } },
1192     { "attachShadowRoot", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAttachShadowRoot), (intptr_t) (1) } },
1193     { "entries", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionEntries), (intptr_t) (0) } },
1194     { "keys", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionKeys), (intptr_t) (0) } },
1195     { "values", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionValues), (intptr_t) (0) } },
1196     { "forEach", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionForEach), (intptr_t) (1) } },
1197 #if ENABLE(Condition1)
1198     { "CONDITIONAL_CONST", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
1199 #else
1200     { 0, 0, NoIntrinsic, { 0, 0 } },
1201 #endif
1202     { "CONST_VALUE_0", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
1203     { "CONST_VALUE_1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
1204     { "CONST_VALUE_2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
1205     { "CONST_VALUE_4", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(4) } },
1206     { "CONST_VALUE_8", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(8) } },
1207     { "CONST_VALUE_9", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(-1) } },
1208     { "CONST_VALUE_11", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0xffffffff) } },
1209     { "CONST_VALUE_12", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x01) } },
1210     { "CONST_VALUE_13", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0X20) } },
1211     { "CONST_VALUE_14", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x1abc) } },
1212     { "CONST_JAVASCRIPT", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(15) } },
1213     { "readonly", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
1214 };
1215
1216 const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
1217
1218 void JSTestObjPrototype::finishCreation(VM& vm)
1219 {
1220     Base::finishCreation(vm);
1221     reifyStaticProperties(vm, JSTestObjPrototypeTableValues, *this);
1222 #if ENABLE(TEST_FEATURE)
1223     if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
1224         Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>("enabledAtRuntimeOperation"), strlen("enabledAtRuntimeOperation"));
1225         removeDirect(vm, propertyName);
1226     }
1227 #endif
1228 #if ENABLE(TEST_FEATURE)
1229     if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
1230         Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>("enabledAtRuntimeAttribute"), strlen("enabledAtRuntimeAttribute"));
1231         removeDirect(vm, propertyName);
1232     }
1233 #endif
1234     JSVMClientData& clientData = *static_cast<JSVMClientData*>(vm.clientData);
1235     putDirect(vm, clientData.builtinNames().privateMethodPrivateName(), JSFunction::create(vm, globalObject(), 0, String(), jsTestObjPrototypeFunctionPrivateMethod), ReadOnly | DontEnum);
1236     putDirect(vm, vm.propertyNames->iteratorSymbol, JSFunction::create(vm, globalObject(), 0, ASCIILiteral("[Symbol.Iterator]"), jsTestObjPrototypeFunctionSymbolIterator), ReadOnly | DontEnum);
1237 }
1238
1239 const ClassInfo JSTestObj::s_info = { "TestObject", &Base::s_info, &JSTestObjTable, CREATE_METHOD_TABLE(JSTestObj) };
1240
1241 JSTestObj::JSTestObj(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestObj>&& impl)
1242     : JSDOMWrapper<TestObj>(structure, globalObject, WTFMove(impl))
1243 {
1244 }
1245
1246 JSObject* JSTestObj::createPrototype(VM& vm, JSGlobalObject* globalObject)
1247 {
1248     return JSTestObjPrototype::create(vm, globalObject, JSTestObjPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
1249 }
1250
1251 JSObject* JSTestObj::prototype(VM& vm, JSGlobalObject* globalObject)
1252 {
1253     return getDOMPrototype<JSTestObj>(vm, globalObject);
1254 }
1255
1256 void JSTestObj::destroy(JSC::JSCell* cell)
1257 {
1258     JSTestObj* thisObject = static_cast<JSTestObj*>(cell);
1259     thisObject->JSTestObj::~JSTestObj();
1260 }
1261
1262 bool JSTestObj::getOwnPropertySlot(JSObject* object, ExecState* state, PropertyName propertyName, PropertySlot& slot)
1263 {
1264     auto* thisObject = jsCast<JSTestObj*>(object);
1265     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
1266     Optional<uint32_t> optionalIndex = parseIndex(propertyName);
1267     if (optionalIndex) {
1268         unsigned index = optionalIndex.value();
1269         unsigned attributes = DontDelete | ReadOnly;
1270         slot.setValue(thisObject, attributes, jsStringOrUndefined(state, thisObject->wrapped().item(index)));
1271         return true;
1272     }
1273     if (getStaticPropertySlot<JSTestObj, Base>(state, JSTestObjTable, thisObject, propertyName, slot))
1274         return true;
1275     return false;
1276 }
1277
1278 bool JSTestObj::getOwnPropertySlotByIndex(JSObject* object, ExecState* state, unsigned index, PropertySlot& slot)
1279 {
1280     auto* thisObject = jsCast<JSTestObj*>(object);
1281     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
1282     if (LIKELY(index <= MAX_ARRAY_INDEX)) {
1283         unsigned attributes = DontDelete | ReadOnly;
1284         slot.setValue(thisObject, attributes, jsStringOrUndefined(state, thisObject->wrapped().item(index)));
1285         return true;
1286     }
1287     return Base::getOwnPropertySlotByIndex(thisObject, state, index, slot);
1288 }
1289
1290 EncodedJSValue jsTestObjReadOnlyLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1291 {
1292     UNUSED_PARAM(state);
1293     UNUSED_PARAM(thisValue);
1294     JSValue decodedThisValue = JSValue::decode(thisValue);
1295     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1296     if (UNLIKELY(!castedThis)) {
1297         return throwGetterTypeError(*state, "TestObj", "readOnlyLongAttr");
1298     }
1299     auto& impl = castedThis->wrapped();
1300     JSValue result = jsNumber(impl.readOnlyLongAttr());
1301     return JSValue::encode(result);
1302 }
1303
1304
1305 EncodedJSValue jsTestObjReadOnlyStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1306 {
1307     UNUSED_PARAM(state);
1308     UNUSED_PARAM(thisValue);
1309     JSValue decodedThisValue = JSValue::decode(thisValue);
1310     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1311     if (UNLIKELY(!castedThis)) {
1312         return throwGetterTypeError(*state, "TestObj", "readOnlyStringAttr");
1313     }
1314     auto& impl = castedThis->wrapped();
1315     JSValue result = jsStringWithCache(state, impl.readOnlyStringAttr());
1316     return JSValue::encode(result);
1317 }
1318
1319
1320 EncodedJSValue jsTestObjReadOnlyTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1321 {
1322     UNUSED_PARAM(state);
1323     UNUSED_PARAM(thisValue);
1324     JSValue decodedThisValue = JSValue::decode(thisValue);
1325     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1326     if (UNLIKELY(!castedThis)) {
1327         return throwGetterTypeError(*state, "TestObj", "readOnlyTestObjAttr");
1328     }
1329     auto& impl = castedThis->wrapped();
1330     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.readOnlyTestObjAttr()));
1331     return JSValue::encode(result);
1332 }
1333
1334
1335 EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1336 {
1337     UNUSED_PARAM(state);
1338     UNUSED_PARAM(thisValue);
1339     JSValue result = jsNumber(TestObj::staticReadOnlyLongAttr());
1340     return JSValue::encode(result);
1341 }
1342
1343
1344 EncodedJSValue jsTestObjConstructorStaticStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1345 {
1346     UNUSED_PARAM(state);
1347     UNUSED_PARAM(thisValue);
1348     JSValue result = jsStringWithCache(state, TestObj::staticStringAttr());
1349     return JSValue::encode(result);
1350 }
1351
1352
1353 EncodedJSValue jsTestObjConstructorTestSubObj(ExecState* state, EncodedJSValue thisValue, PropertyName)
1354 {
1355     UNUSED_PARAM(state);
1356     UNUSED_PARAM(thisValue);
1357     JSValue decodedThisValue = JSValue::decode(thisValue);
1358     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1359     if (UNLIKELY(!castedThis)) {
1360         return throwGetterTypeError(*state, "TestObj", "TestSubObj");
1361     }
1362     return JSValue::encode(JSTestSubObj::getConstructor(state->vm(), castedThis->globalObject()));
1363 }
1364
1365
1366 EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
1367 {
1368     UNUSED_PARAM(state);
1369     UNUSED_PARAM(thisValue);
1370     JSValue decodedThisValue = JSValue::decode(thisValue);
1371     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1372     if (UNLIKELY(!castedThis)) {
1373         return throwGetterTypeError(*state, "TestObj", "TestSubObjEnabledBySetting");
1374     }
1375     if (UNLIKELY(!castedThis->wrapped().frame()))
1376         return JSValue::encode(jsUndefined());
1377     Settings& settings = castedThis->wrapped().frame()->settings();
1378     if (!settings.testSettingEnabled())
1379         return JSValue::encode(jsUndefined());
1380     return JSValue::encode(JSTestSubObj::getConstructor(state->vm(), castedThis->globalObject()));
1381 }
1382
1383
1384 EncodedJSValue jsTestObjEnumAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1385 {
1386     UNUSED_PARAM(state);
1387     UNUSED_PARAM(thisValue);
1388     JSValue decodedThisValue = JSValue::decode(thisValue);
1389     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1390     if (UNLIKELY(!castedThis)) {
1391         return throwGetterTypeError(*state, "TestObj", "enumAttr");
1392     }
1393     auto& impl = castedThis->wrapped();
1394     JSValue result = jsStringWithCache(state, impl.enumAttr());
1395     return JSValue::encode(result);
1396 }
1397
1398
1399 EncodedJSValue jsTestObjByteAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1400 {
1401     UNUSED_PARAM(state);
1402     UNUSED_PARAM(thisValue);
1403     JSValue decodedThisValue = JSValue::decode(thisValue);
1404     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1405     if (UNLIKELY(!castedThis)) {
1406         return throwGetterTypeError(*state, "TestObj", "byteAttr");
1407     }
1408     auto& impl = castedThis->wrapped();
1409     JSValue result = jsNumber(impl.byteAttr());
1410     return JSValue::encode(result);
1411 }
1412
1413
1414 EncodedJSValue jsTestObjOctetAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1415 {
1416     UNUSED_PARAM(state);
1417     UNUSED_PARAM(thisValue);
1418     JSValue decodedThisValue = JSValue::decode(thisValue);
1419     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1420     if (UNLIKELY(!castedThis)) {
1421         return throwGetterTypeError(*state, "TestObj", "octetAttr");
1422     }
1423     auto& impl = castedThis->wrapped();
1424     JSValue result = jsNumber(impl.octetAttr());
1425     return JSValue::encode(result);
1426 }
1427
1428
1429 EncodedJSValue jsTestObjShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1430 {
1431     UNUSED_PARAM(state);
1432     UNUSED_PARAM(thisValue);
1433     JSValue decodedThisValue = JSValue::decode(thisValue);
1434     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1435     if (UNLIKELY(!castedThis)) {
1436         return throwGetterTypeError(*state, "TestObj", "shortAttr");
1437     }
1438     auto& impl = castedThis->wrapped();
1439     JSValue result = jsNumber(impl.shortAttr());
1440     return JSValue::encode(result);
1441 }
1442
1443
1444 EncodedJSValue jsTestObjClampedShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1445 {
1446     UNUSED_PARAM(state);
1447     UNUSED_PARAM(thisValue);
1448     JSValue decodedThisValue = JSValue::decode(thisValue);
1449     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1450     if (UNLIKELY(!castedThis)) {
1451         return throwGetterTypeError(*state, "TestObj", "clampedShortAttr");
1452     }
1453     auto& impl = castedThis->wrapped();
1454     JSValue result = jsNumber(impl.clampedShortAttr());
1455     return JSValue::encode(result);
1456 }
1457
1458
1459 EncodedJSValue jsTestObjEnforceRangeShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1460 {
1461     UNUSED_PARAM(state);
1462     UNUSED_PARAM(thisValue);
1463     JSValue decodedThisValue = JSValue::decode(thisValue);
1464     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1465     if (UNLIKELY(!castedThis)) {
1466         return throwGetterTypeError(*state, "TestObj", "enforceRangeShortAttr");
1467     }
1468     auto& impl = castedThis->wrapped();
1469     JSValue result = jsNumber(impl.enforceRangeShortAttr());
1470     return JSValue::encode(result);
1471 }
1472
1473
1474 EncodedJSValue jsTestObjUnsignedShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1475 {
1476     UNUSED_PARAM(state);
1477     UNUSED_PARAM(thisValue);
1478     JSValue decodedThisValue = JSValue::decode(thisValue);
1479     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1480     if (UNLIKELY(!castedThis)) {
1481         return throwGetterTypeError(*state, "TestObj", "unsignedShortAttr");
1482     }
1483     auto& impl = castedThis->wrapped();
1484     JSValue result = jsNumber(impl.unsignedShortAttr());
1485     return JSValue::encode(result);
1486 }
1487
1488
1489 EncodedJSValue jsTestObjLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1490 {
1491     UNUSED_PARAM(state);
1492     UNUSED_PARAM(thisValue);
1493     JSValue decodedThisValue = JSValue::decode(thisValue);
1494     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1495     if (UNLIKELY(!castedThis)) {
1496         return throwGetterTypeError(*state, "TestObj", "longAttr");
1497     }
1498     auto& impl = castedThis->wrapped();
1499     JSValue result = jsNumber(impl.longAttr());
1500     return JSValue::encode(result);
1501 }
1502
1503
1504 EncodedJSValue jsTestObjLongLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1505 {
1506     UNUSED_PARAM(state);
1507     UNUSED_PARAM(thisValue);
1508     JSValue decodedThisValue = JSValue::decode(thisValue);
1509     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1510     if (UNLIKELY(!castedThis)) {
1511         return throwGetterTypeError(*state, "TestObj", "longLongAttr");
1512     }
1513     auto& impl = castedThis->wrapped();
1514     JSValue result = jsNumber(impl.longLongAttr());
1515     return JSValue::encode(result);
1516 }
1517
1518
1519 EncodedJSValue jsTestObjUnsignedLongLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1520 {
1521     UNUSED_PARAM(state);
1522     UNUSED_PARAM(thisValue);
1523     JSValue decodedThisValue = JSValue::decode(thisValue);
1524     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1525     if (UNLIKELY(!castedThis)) {
1526         return throwGetterTypeError(*state, "TestObj", "unsignedLongLongAttr");
1527     }
1528     auto& impl = castedThis->wrapped();
1529     JSValue result = jsNumber(impl.unsignedLongLongAttr());
1530     return JSValue::encode(result);
1531 }
1532
1533
1534 EncodedJSValue jsTestObjStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1535 {
1536     UNUSED_PARAM(state);
1537     UNUSED_PARAM(thisValue);
1538     JSValue decodedThisValue = JSValue::decode(thisValue);
1539     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1540     if (UNLIKELY(!castedThis)) {
1541         return throwGetterTypeError(*state, "TestObj", "stringAttr");
1542     }
1543     auto& impl = castedThis->wrapped();
1544     JSValue result = jsStringWithCache(state, impl.stringAttr());
1545     return JSValue::encode(result);
1546 }
1547
1548
1549 EncodedJSValue jsTestObjTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1550 {
1551     UNUSED_PARAM(state);
1552     UNUSED_PARAM(thisValue);
1553     JSValue decodedThisValue = JSValue::decode(thisValue);
1554     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1555     if (UNLIKELY(!castedThis)) {
1556         return throwGetterTypeError(*state, "TestObj", "testObjAttr");
1557     }
1558     auto& impl = castedThis->wrapped();
1559     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.testObjAttr()));
1560     return JSValue::encode(result);
1561 }
1562
1563
1564 EncodedJSValue jsTestObjTestNullableObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1565 {
1566     UNUSED_PARAM(state);
1567     UNUSED_PARAM(thisValue);
1568     JSValue decodedThisValue = JSValue::decode(thisValue);
1569     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1570     if (UNLIKELY(!castedThis)) {
1571         return throwGetterTypeError(*state, "TestObj", "testNullableObjAttr");
1572     }
1573     auto& impl = castedThis->wrapped();
1574     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.testNullableObjAttr()));
1575     return JSValue::encode(result);
1576 }
1577
1578
1579 EncodedJSValue jsTestObjLenientTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1580 {
1581     UNUSED_PARAM(state);
1582     UNUSED_PARAM(thisValue);
1583     JSValue decodedThisValue = JSValue::decode(thisValue);
1584     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1585     if (UNLIKELY(!castedThis)) {
1586         return JSValue::encode(jsUndefined());
1587     }
1588     auto& impl = castedThis->wrapped();
1589     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.lenientTestObjAttr()));
1590     return JSValue::encode(result);
1591 }
1592
1593
1594 EncodedJSValue jsTestObjUnforgeableAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1595 {
1596     UNUSED_PARAM(state);
1597     UNUSED_PARAM(thisValue);
1598     JSValue decodedThisValue = JSValue::decode(thisValue);
1599     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1600     if (UNLIKELY(!castedThis)) {
1601         return throwGetterTypeError(*state, "TestObj", "unforgeableAttr");
1602     }
1603     auto& impl = castedThis->wrapped();
1604     JSValue result = jsStringWithCache(state, impl.unforgeableAttr());
1605     return JSValue::encode(result);
1606 }
1607
1608
1609 EncodedJSValue jsTestObjStringAttrTreatingNullAsEmptyString(ExecState* state, EncodedJSValue thisValue, PropertyName)
1610 {
1611     UNUSED_PARAM(state);
1612     UNUSED_PARAM(thisValue);
1613     JSValue decodedThisValue = JSValue::decode(thisValue);
1614     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1615     if (UNLIKELY(!castedThis)) {
1616         return throwGetterTypeError(*state, "TestObj", "stringAttrTreatingNullAsEmptyString");
1617     }
1618     auto& impl = castedThis->wrapped();
1619     JSValue result = jsStringWithCache(state, impl.stringAttrTreatingNullAsEmptyString());
1620     return JSValue::encode(result);
1621 }
1622
1623
1624 EncodedJSValue jsTestObjXMLObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1625 {
1626     UNUSED_PARAM(state);
1627     UNUSED_PARAM(thisValue);
1628     JSValue decodedThisValue = JSValue::decode(thisValue);
1629     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1630     if (UNLIKELY(!castedThis)) {
1631         return throwGetterTypeError(*state, "TestObj", "XMLObjAttr");
1632     }
1633     auto& impl = castedThis->wrapped();
1634     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.xmlObjAttr()));
1635     return JSValue::encode(result);
1636 }
1637
1638
1639 EncodedJSValue jsTestObjCreate(ExecState* state, EncodedJSValue thisValue, PropertyName)
1640 {
1641     UNUSED_PARAM(state);
1642     UNUSED_PARAM(thisValue);
1643     JSValue decodedThisValue = JSValue::decode(thisValue);
1644     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1645     if (UNLIKELY(!castedThis)) {
1646         return throwGetterTypeError(*state, "TestObj", "create");
1647     }
1648     auto& impl = castedThis->wrapped();
1649     JSValue result = jsBoolean(impl.isCreate());
1650     return JSValue::encode(result);
1651 }
1652
1653
1654 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1655 {
1656     UNUSED_PARAM(state);
1657     UNUSED_PARAM(thisValue);
1658     JSValue decodedThisValue = JSValue::decode(thisValue);
1659     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1660     if (UNLIKELY(!castedThis)) {
1661         return throwGetterTypeError(*state, "TestObj", "reflectedStringAttr");
1662     }
1663     auto& impl = castedThis->wrapped();
1664     JSValue result = jsStringWithCache(state, impl.fastGetAttribute(WebCore::HTMLNames::reflectedstringattrAttr));
1665     return JSValue::encode(result);
1666 }
1667
1668
1669 EncodedJSValue jsTestObjReflectedIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1670 {
1671     UNUSED_PARAM(state);
1672     UNUSED_PARAM(thisValue);
1673     JSValue decodedThisValue = JSValue::decode(thisValue);
1674     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1675     if (UNLIKELY(!castedThis)) {
1676         return throwGetterTypeError(*state, "TestObj", "reflectedIntegralAttr");
1677     }
1678     auto& impl = castedThis->wrapped();
1679     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr));
1680     return JSValue::encode(result);
1681 }
1682
1683
1684 EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1685 {
1686     UNUSED_PARAM(state);
1687     UNUSED_PARAM(thisValue);
1688     JSValue decodedThisValue = JSValue::decode(thisValue);
1689     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1690     if (UNLIKELY(!castedThis)) {
1691         return throwGetterTypeError(*state, "TestObj", "reflectedUnsignedIntegralAttr");
1692     }
1693     auto& impl = castedThis->wrapped();
1694     JSValue result = jsNumber(std::max(0, impl.getIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr)));
1695     return JSValue::encode(result);
1696 }
1697
1698
1699 EncodedJSValue jsTestObjReflectedBooleanAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1700 {
1701     UNUSED_PARAM(state);
1702     UNUSED_PARAM(thisValue);
1703     JSValue decodedThisValue = JSValue::decode(thisValue);
1704     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1705     if (UNLIKELY(!castedThis)) {
1706         return throwGetterTypeError(*state, "TestObj", "reflectedBooleanAttr");
1707     }
1708     auto& impl = castedThis->wrapped();
1709     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr));
1710     return JSValue::encode(result);
1711 }
1712
1713
1714 EncodedJSValue jsTestObjReflectedURLAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1715 {
1716     UNUSED_PARAM(state);
1717     UNUSED_PARAM(thisValue);
1718     JSValue decodedThisValue = JSValue::decode(thisValue);
1719     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1720     if (UNLIKELY(!castedThis)) {
1721         return throwGetterTypeError(*state, "TestObj", "reflectedURLAttr");
1722     }
1723     auto& impl = castedThis->wrapped();
1724     JSValue result = jsStringWithCache(state, impl.getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr));
1725     return JSValue::encode(result);
1726 }
1727
1728
1729 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1730 {
1731     UNUSED_PARAM(state);
1732     UNUSED_PARAM(thisValue);
1733     JSValue decodedThisValue = JSValue::decode(thisValue);
1734     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1735     if (UNLIKELY(!castedThis)) {
1736         return throwGetterTypeError(*state, "TestObj", "reflectedStringAttr");
1737     }
1738     auto& impl = castedThis->wrapped();
1739     JSValue result = jsStringWithCache(state, impl.fastGetAttribute(WebCore::HTMLNames::customContentStringAttrAttr));
1740     return JSValue::encode(result);
1741 }
1742
1743
1744 EncodedJSValue jsTestObjReflectedCustomIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1745 {
1746     UNUSED_PARAM(state);
1747     UNUSED_PARAM(thisValue);
1748     JSValue decodedThisValue = JSValue::decode(thisValue);
1749     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1750     if (UNLIKELY(!castedThis)) {
1751         return throwGetterTypeError(*state, "TestObj", "reflectedCustomIntegralAttr");
1752     }
1753     auto& impl = castedThis->wrapped();
1754     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr));
1755     return JSValue::encode(result);
1756 }
1757
1758
1759 EncodedJSValue jsTestObjReflectedCustomBooleanAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1760 {
1761     UNUSED_PARAM(state);
1762     UNUSED_PARAM(thisValue);
1763     JSValue decodedThisValue = JSValue::decode(thisValue);
1764     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1765     if (UNLIKELY(!castedThis)) {
1766         return throwGetterTypeError(*state, "TestObj", "reflectedCustomBooleanAttr");
1767     }
1768     auto& impl = castedThis->wrapped();
1769     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr));
1770     return JSValue::encode(result);
1771 }
1772
1773
1774 EncodedJSValue jsTestObjReflectedCustomURLAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1775 {
1776     UNUSED_PARAM(state);
1777     UNUSED_PARAM(thisValue);
1778     JSValue decodedThisValue = JSValue::decode(thisValue);
1779     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1780     if (UNLIKELY(!castedThis)) {
1781         return throwGetterTypeError(*state, "TestObj", "reflectedCustomURLAttr");
1782     }
1783     auto& impl = castedThis->wrapped();
1784     JSValue result = jsStringWithCache(state, impl.getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr));
1785     return JSValue::encode(result);
1786 }
1787
1788
1789 #if ENABLE(TEST_FEATURE)
1790 EncodedJSValue jsTestObjEnabledAtRuntimeAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1791 {
1792     UNUSED_PARAM(state);
1793     UNUSED_PARAM(thisValue);
1794     JSValue decodedThisValue = JSValue::decode(thisValue);
1795     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1796     if (UNLIKELY(!castedThis)) {
1797         return throwGetterTypeError(*state, "TestObj", "enabledAtRuntimeAttribute");
1798     }
1799     auto& impl = castedThis->wrapped();
1800     JSValue result = jsStringWithCache(state, impl.enabledAtRuntimeAttribute());
1801     return JSValue::encode(result);
1802 }
1803
1804 #endif
1805
1806 EncodedJSValue jsTestObjTypedArrayAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1807 {
1808     UNUSED_PARAM(state);
1809     UNUSED_PARAM(thisValue);
1810     JSValue decodedThisValue = JSValue::decode(thisValue);
1811     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1812     if (UNLIKELY(!castedThis)) {
1813         return throwGetterTypeError(*state, "TestObj", "typedArrayAttr");
1814     }
1815     auto& impl = castedThis->wrapped();
1816     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.typedArrayAttr()));
1817     return JSValue::encode(result);
1818 }
1819
1820
1821 EncodedJSValue jsTestObjAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1822 {
1823     UNUSED_PARAM(state);
1824     UNUSED_PARAM(thisValue);
1825     JSValue decodedThisValue = JSValue::decode(thisValue);
1826     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1827     if (UNLIKELY(!castedThis)) {
1828         return throwGetterTypeError(*state, "TestObj", "attrWithGetterException");
1829     }
1830     ExceptionCode ec = 0;
1831     auto& impl = castedThis->wrapped();
1832     JSValue result = jsNumber(impl.attrWithGetterException(ec));
1833     setDOMException(state, ec);
1834     return JSValue::encode(result);
1835 }
1836
1837
1838 EncodedJSValue jsTestObjAttrWithGetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, PropertyName)
1839 {
1840     UNUSED_PARAM(state);
1841     UNUSED_PARAM(thisValue);
1842     JSValue decodedThisValue = JSValue::decode(thisValue);
1843     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1844     if (UNLIKELY(!castedThis)) {
1845         return throwGetterTypeError(*state, "TestObj", "attrWithGetterExceptionWithMessage");
1846     }
1847     ExceptionCodeWithMessage ec;
1848     auto& impl = castedThis->wrapped();
1849     JSValue result = jsNumber(impl.attrWithGetterExceptionWithMessage(ec));
1850     setDOMException(state, ec);
1851     return JSValue::encode(result);
1852 }
1853
1854
1855 EncodedJSValue jsTestObjAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1856 {
1857     UNUSED_PARAM(state);
1858     UNUSED_PARAM(thisValue);
1859     JSValue decodedThisValue = JSValue::decode(thisValue);
1860     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1861     if (UNLIKELY(!castedThis)) {
1862         return throwGetterTypeError(*state, "TestObj", "attrWithSetterException");
1863     }
1864     auto& impl = castedThis->wrapped();
1865     JSValue result = jsNumber(impl.attrWithSetterException());
1866     return JSValue::encode(result);
1867 }
1868
1869
1870 EncodedJSValue jsTestObjAttrWithSetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, PropertyName)
1871 {
1872     UNUSED_PARAM(state);
1873     UNUSED_PARAM(thisValue);
1874     JSValue decodedThisValue = JSValue::decode(thisValue);
1875     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1876     if (UNLIKELY(!castedThis)) {
1877         return throwGetterTypeError(*state, "TestObj", "attrWithSetterExceptionWithMessage");
1878     }
1879     auto& impl = castedThis->wrapped();
1880     JSValue result = jsNumber(impl.attrWithSetterExceptionWithMessage());
1881     return JSValue::encode(result);
1882 }
1883
1884
1885 EncodedJSValue jsTestObjStringAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1886 {
1887     UNUSED_PARAM(state);
1888     UNUSED_PARAM(thisValue);
1889     JSValue decodedThisValue = JSValue::decode(thisValue);
1890     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1891     if (UNLIKELY(!castedThis)) {
1892         return throwGetterTypeError(*state, "TestObj", "stringAttrWithGetterException");
1893     }
1894     ExceptionCode ec = 0;
1895     auto& impl = castedThis->wrapped();
1896     JSValue result = jsStringWithCache(state, impl.stringAttrWithGetterException(ec));
1897     setDOMException(state, ec);
1898     return JSValue::encode(result);
1899 }
1900
1901
1902 EncodedJSValue jsTestObjStringAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1903 {
1904     UNUSED_PARAM(state);
1905     UNUSED_PARAM(thisValue);
1906     JSValue decodedThisValue = JSValue::decode(thisValue);
1907     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1908     if (UNLIKELY(!castedThis)) {
1909         return throwGetterTypeError(*state, "TestObj", "stringAttrWithSetterException");
1910     }
1911     auto& impl = castedThis->wrapped();
1912     JSValue result = jsStringWithCache(state, impl.stringAttrWithSetterException());
1913     return JSValue::encode(result);
1914 }
1915
1916
1917 EncodedJSValue jsTestObjStrictTypeCheckingAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1918 {
1919     UNUSED_PARAM(state);
1920     UNUSED_PARAM(thisValue);
1921     JSValue decodedThisValue = JSValue::decode(thisValue);
1922     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1923     if (UNLIKELY(!castedThis)) {
1924         return throwGetterTypeError(*state, "TestObj", "strictTypeCheckingAttribute");
1925     }
1926     auto& impl = castedThis->wrapped();
1927     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.strictTypeCheckingAttribute()));
1928     return JSValue::encode(result);
1929 }
1930
1931
1932 EncodedJSValue jsTestObjCustomAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1933 {
1934     UNUSED_PARAM(state);
1935     UNUSED_PARAM(thisValue);
1936     JSValue decodedThisValue = JSValue::decode(thisValue);
1937     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1938     if (UNLIKELY(!castedThis)) {
1939         return throwGetterTypeError(*state, "TestObj", "customAttr");
1940     }
1941     return JSValue::encode(castedThis->customAttr(*state));
1942 }
1943
1944
1945 EncodedJSValue jsTestObjOnfoo(ExecState* state, EncodedJSValue thisValue, PropertyName)
1946 {
1947     UNUSED_PARAM(state);
1948     UNUSED_PARAM(thisValue);
1949     JSValue decodedThisValue = JSValue::decode(thisValue);
1950     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1951     if (UNLIKELY(!castedThis)) {
1952         return throwGetterTypeError(*state, "TestObj", "onfoo");
1953     }
1954     UNUSED_PARAM(state);
1955     return JSValue::encode(eventHandlerAttribute(castedThis->wrapped(), eventNames().fooEvent));
1956 }
1957
1958
1959 EncodedJSValue jsTestObjOnwebkitfoo(ExecState* state, EncodedJSValue thisValue, PropertyName)
1960 {
1961     UNUSED_PARAM(state);
1962     UNUSED_PARAM(thisValue);
1963     JSValue decodedThisValue = JSValue::decode(thisValue);
1964     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1965     if (UNLIKELY(!castedThis)) {
1966         return throwGetterTypeError(*state, "TestObj", "onwebkitfoo");
1967     }
1968     UNUSED_PARAM(state);
1969     return JSValue::encode(eventHandlerAttribute(castedThis->wrapped(), eventNames().fooEvent));
1970 }
1971
1972
1973 EncodedJSValue jsTestObjWithScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1974 {
1975     UNUSED_PARAM(state);
1976     UNUSED_PARAM(thisValue);
1977     JSValue decodedThisValue = JSValue::decode(thisValue);
1978     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1979     if (UNLIKELY(!castedThis)) {
1980         return throwGetterTypeError(*state, "TestObj", "withScriptStateAttribute");
1981     }
1982     auto& impl = castedThis->wrapped();
1983     JSValue result = jsNumber(impl.withScriptStateAttribute(*state));
1984     return JSValue::encode(result);
1985 }
1986
1987
1988 EncodedJSValue jsTestObjWithCallWithAndSetterCallWithAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1989 {
1990     UNUSED_PARAM(state);
1991     UNUSED_PARAM(thisValue);
1992     JSValue decodedThisValue = JSValue::decode(thisValue);
1993     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1994     if (UNLIKELY(!castedThis)) {
1995         return throwGetterTypeError(*state, "TestObj", "withCallWithAndSetterCallWithAttribute");
1996     }
1997     auto& impl = castedThis->wrapped();
1998     JSValue result = jsNumber(impl.withCallWithAndSetterCallWithAttribute(*state));
1999     return JSValue::encode(result);
2000 }
2001
2002
2003 EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2004 {
2005     UNUSED_PARAM(state);
2006     UNUSED_PARAM(thisValue);
2007     JSValue decodedThisValue = JSValue::decode(thisValue);
2008     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2009     if (UNLIKELY(!castedThis)) {
2010         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAttribute");
2011     }
2012     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2013     if (!context)
2014         return JSValue::encode(jsUndefined());
2015     auto& impl = castedThis->wrapped();
2016     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttribute(*context)));
2017     return JSValue::encode(result);
2018 }
2019
2020
2021 EncodedJSValue jsTestObjWithScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
2022 {
2023     UNUSED_PARAM(state);
2024     UNUSED_PARAM(thisValue);
2025     JSValue decodedThisValue = JSValue::decode(thisValue);
2026     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2027     if (UNLIKELY(!castedThis)) {
2028         return throwGetterTypeError(*state, "TestObj", "withScriptStateAttributeRaises");
2029     }
2030     ExceptionCode ec = 0;
2031     auto& impl = castedThis->wrapped();
2032     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(*state, ec)));
2033     setDOMException(state, ec);
2034     return JSValue::encode(result);
2035 }
2036
2037
2038 EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
2039 {
2040     UNUSED_PARAM(state);
2041     UNUSED_PARAM(thisValue);
2042     JSValue decodedThisValue = JSValue::decode(thisValue);
2043     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2044     if (UNLIKELY(!castedThis)) {
2045         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAttributeRaises");
2046     }
2047     ExceptionCode ec = 0;
2048     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2049     if (!context)
2050         return JSValue::encode(jsUndefined());
2051     auto& impl = castedThis->wrapped();
2052     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(*context, ec)));
2053     setDOMException(state, ec);
2054     return JSValue::encode(result);
2055 }
2056
2057
2058 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(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", "withScriptExecutionContextAndScriptStateAttribute");
2066     }
2067     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2068     if (!context)
2069         return JSValue::encode(jsUndefined());
2070     auto& impl = castedThis->wrapped();
2071     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttribute(*state, *context)));
2072     return JSValue::encode(result);
2073 }
2074
2075
2076 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
2077 {
2078     UNUSED_PARAM(state);
2079     UNUSED_PARAM(thisValue);
2080     JSValue decodedThisValue = JSValue::decode(thisValue);
2081     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2082     if (UNLIKELY(!castedThis)) {
2083         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
2084     }
2085     ExceptionCode ec = 0;
2086     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2087     if (!context)
2088         return JSValue::encode(jsUndefined());
2089     auto& impl = castedThis->wrapped();
2090     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(*state, *context, ec)));
2091     setDOMException(state, ec);
2092     return JSValue::encode(result);
2093 }
2094
2095
2096 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(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", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
2104     }
2105     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2106     if (!context)
2107         return JSValue::encode(jsUndefined());
2108     auto& impl = castedThis->wrapped();
2109     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpacesAttribute(*state, *context)));
2110     return JSValue::encode(result);
2111 }
2112
2113
2114 EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2115 {
2116     UNUSED_PARAM(state);
2117     UNUSED_PARAM(thisValue);
2118     JSValue decodedThisValue = JSValue::decode(thisValue);
2119     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2120     if (UNLIKELY(!castedThis)) {
2121         return throwGetterTypeError(*state, "TestObj", "withScriptArgumentsAndCallStackAttribute");
2122     }
2123     auto& impl = castedThis->wrapped();
2124     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptArgumentsAndCallStackAttribute()));
2125     return JSValue::encode(result);
2126 }
2127
2128
2129 #if ENABLE(Condition1)
2130 EncodedJSValue jsTestObjConditionalAttr1(ExecState* state, EncodedJSValue thisValue, PropertyName)
2131 {
2132     UNUSED_PARAM(state);
2133     UNUSED_PARAM(thisValue);
2134     JSValue decodedThisValue = JSValue::decode(thisValue);
2135     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2136     if (UNLIKELY(!castedThis)) {
2137         return throwGetterTypeError(*state, "TestObj", "conditionalAttr1");
2138     }
2139     auto& impl = castedThis->wrapped();
2140     JSValue result = jsNumber(impl.conditionalAttr1());
2141     return JSValue::encode(result);
2142 }
2143
2144 #endif
2145
2146 #if ENABLE(Condition1) && ENABLE(Condition2)
2147 EncodedJSValue jsTestObjConditionalAttr2(ExecState* state, EncodedJSValue thisValue, PropertyName)
2148 {
2149     UNUSED_PARAM(state);
2150     UNUSED_PARAM(thisValue);
2151     JSValue decodedThisValue = JSValue::decode(thisValue);
2152     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2153     if (UNLIKELY(!castedThis)) {
2154         return throwGetterTypeError(*state, "TestObj", "conditionalAttr2");
2155     }
2156     auto& impl = castedThis->wrapped();
2157     JSValue result = jsNumber(impl.conditionalAttr2());
2158     return JSValue::encode(result);
2159 }
2160
2161 #endif
2162
2163 #if ENABLE(Condition1) || ENABLE(Condition2)
2164 EncodedJSValue jsTestObjConditionalAttr3(ExecState* state, EncodedJSValue thisValue, PropertyName)
2165 {
2166     UNUSED_PARAM(state);
2167     UNUSED_PARAM(thisValue);
2168     JSValue decodedThisValue = JSValue::decode(thisValue);
2169     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2170     if (UNLIKELY(!castedThis)) {
2171         return throwGetterTypeError(*state, "TestObj", "conditionalAttr3");
2172     }
2173     auto& impl = castedThis->wrapped();
2174     JSValue result = jsNumber(impl.conditionalAttr3());
2175     return JSValue::encode(result);
2176 }
2177
2178 #endif
2179
2180 #if ENABLE(Condition1)
2181 EncodedJSValue jsTestObjConditionalAttr4Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2182 {
2183     UNUSED_PARAM(state);
2184     UNUSED_PARAM(thisValue);
2185     JSValue decodedThisValue = JSValue::decode(thisValue);
2186     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2187     if (UNLIKELY(!castedThis)) {
2188         return throwGetterTypeError(*state, "TestObj", "conditionalAttr4");
2189     }
2190     return JSValue::encode(JSTestObjectA::getConstructor(state->vm(), castedThis->globalObject()));
2191 }
2192
2193 #endif
2194
2195 #if ENABLE(Condition1) && ENABLE(Condition2)
2196 EncodedJSValue jsTestObjConditionalAttr5Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2197 {
2198     UNUSED_PARAM(state);
2199     UNUSED_PARAM(thisValue);
2200     JSValue decodedThisValue = JSValue::decode(thisValue);
2201     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2202     if (UNLIKELY(!castedThis)) {
2203         return throwGetterTypeError(*state, "TestObj", "conditionalAttr5");
2204     }
2205     return JSValue::encode(JSTestObjectB::getConstructor(state->vm(), castedThis->globalObject()));
2206 }
2207
2208 #endif
2209
2210 #if ENABLE(Condition1) || ENABLE(Condition2)
2211 EncodedJSValue jsTestObjConditionalAttr6Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2212 {
2213     UNUSED_PARAM(state);
2214     UNUSED_PARAM(thisValue);
2215     JSValue decodedThisValue = JSValue::decode(thisValue);
2216     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2217     if (UNLIKELY(!castedThis)) {
2218         return throwGetterTypeError(*state, "TestObj", "conditionalAttr6");
2219     }
2220     return JSValue::encode(JSTestObjectC::getConstructor(state->vm(), castedThis->globalObject()));
2221 }
2222
2223 #endif
2224
2225 EncodedJSValue jsTestObjCachedAttribute1(ExecState* state, EncodedJSValue thisValue, PropertyName)
2226 {
2227     UNUSED_PARAM(state);
2228     UNUSED_PARAM(thisValue);
2229     JSValue decodedThisValue = JSValue::decode(thisValue);
2230     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2231     if (UNLIKELY(!castedThis)) {
2232         return throwGetterTypeError(*state, "TestObj", "cachedAttribute1");
2233     }
2234     if (JSValue cachedValue = castedThis->m_cachedAttribute1.get())
2235         return JSValue::encode(cachedValue);
2236     auto& impl = castedThis->wrapped();
2237     JSValue result = impl.cachedAttribute1();
2238     castedThis->m_cachedAttribute1.set(state->vm(), castedThis, result);
2239     return JSValue::encode(result);
2240 }
2241
2242
2243 EncodedJSValue jsTestObjCachedAttribute2(ExecState* state, EncodedJSValue thisValue, PropertyName)
2244 {
2245     UNUSED_PARAM(state);
2246     UNUSED_PARAM(thisValue);
2247     JSValue decodedThisValue = JSValue::decode(thisValue);
2248     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2249     if (UNLIKELY(!castedThis)) {
2250         return throwGetterTypeError(*state, "TestObj", "cachedAttribute2");
2251     }
2252     if (JSValue cachedValue = castedThis->m_cachedAttribute2.get())
2253         return JSValue::encode(cachedValue);
2254     auto& impl = castedThis->wrapped();
2255     JSValue result = impl.cachedAttribute2();
2256     castedThis->m_cachedAttribute2.set(state->vm(), castedThis, result);
2257     return JSValue::encode(result);
2258 }
2259
2260
2261 EncodedJSValue jsTestObjAnyAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2262 {
2263     UNUSED_PARAM(state);
2264     UNUSED_PARAM(thisValue);
2265     JSValue decodedThisValue = JSValue::decode(thisValue);
2266     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2267     if (UNLIKELY(!castedThis)) {
2268         return throwGetterTypeError(*state, "TestObj", "anyAttribute");
2269     }
2270     auto& impl = castedThis->wrapped();
2271     JSValue result = impl.anyAttribute();
2272     return JSValue::encode(result);
2273 }
2274
2275
2276 EncodedJSValue jsTestObjContentDocument(ExecState* state, EncodedJSValue thisValue, PropertyName)
2277 {
2278     UNUSED_PARAM(state);
2279     UNUSED_PARAM(thisValue);
2280     JSValue decodedThisValue = JSValue::decode(thisValue);
2281     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2282     if (UNLIKELY(!castedThis)) {
2283         return throwGetterTypeError(*state, "TestObj", "contentDocument");
2284     }
2285     auto& impl = castedThis->wrapped();
2286     return JSValue::encode(shouldAllowAccessToNode(state, impl.contentDocument()) ? toJS(state, castedThis->globalObject(), WTF::getPtr(impl.contentDocument())) : jsNull());
2287 }
2288
2289
2290 EncodedJSValue jsTestObjMutablePoint(ExecState* state, EncodedJSValue thisValue, PropertyName)
2291 {
2292     UNUSED_PARAM(state);
2293     UNUSED_PARAM(thisValue);
2294     JSValue decodedThisValue = JSValue::decode(thisValue);
2295     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2296     if (UNLIKELY(!castedThis)) {
2297         return throwGetterTypeError(*state, "TestObj", "mutablePoint");
2298     }
2299     auto& impl = castedThis->wrapped();
2300     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(SVGStaticPropertyTearOff<TestObj, SVGPoint>::create(impl, impl.mutablePoint(), &TestObj::updateMutablePoint)));
2301     return JSValue::encode(result);
2302 }
2303
2304
2305 EncodedJSValue jsTestObjImmutablePoint(ExecState* state, EncodedJSValue thisValue, PropertyName)
2306 {
2307     UNUSED_PARAM(state);
2308     UNUSED_PARAM(thisValue);
2309     JSValue decodedThisValue = JSValue::decode(thisValue);
2310     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2311     if (UNLIKELY(!castedThis)) {
2312         return throwGetterTypeError(*state, "TestObj", "immutablePoint");
2313     }
2314     auto& impl = castedThis->wrapped();
2315     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePoint())));
2316     return JSValue::encode(result);
2317 }
2318
2319
2320 EncodedJSValue jsTestObjStrawberry(ExecState* state, EncodedJSValue thisValue, PropertyName)
2321 {
2322     UNUSED_PARAM(state);
2323     UNUSED_PARAM(thisValue);
2324     JSValue decodedThisValue = JSValue::decode(thisValue);
2325     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2326     if (UNLIKELY(!castedThis)) {
2327         return throwGetterTypeError(*state, "TestObj", "strawberry");
2328     }
2329     auto& impl = castedThis->wrapped();
2330     JSValue result = jsNumber(impl.blueberry());
2331     return JSValue::encode(result);
2332 }
2333
2334
2335 EncodedJSValue jsTestObjStrictFloat(ExecState* state, EncodedJSValue thisValue, PropertyName)
2336 {
2337     UNUSED_PARAM(state);
2338     UNUSED_PARAM(thisValue);
2339     JSValue decodedThisValue = JSValue::decode(thisValue);
2340     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2341     if (UNLIKELY(!castedThis)) {
2342         return throwGetterTypeError(*state, "TestObj", "strictFloat");
2343     }
2344     auto& impl = castedThis->wrapped();
2345     JSValue result = jsNumber(impl.strictFloat());
2346     return JSValue::encode(result);
2347 }
2348
2349
2350 EncodedJSValue jsTestObjDescription(ExecState* state, EncodedJSValue thisValue, PropertyName)
2351 {
2352     UNUSED_PARAM(state);
2353     UNUSED_PARAM(thisValue);
2354     JSValue decodedThisValue = JSValue::decode(thisValue);
2355     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2356     if (UNLIKELY(!castedThis)) {
2357         return throwGetterTypeError(*state, "TestObj", "description");
2358     }
2359     auto& impl = castedThis->wrapped();
2360     JSValue result = jsNumber(impl.description());
2361     return JSValue::encode(result);
2362 }
2363
2364
2365 EncodedJSValue jsTestObjId(ExecState* state, EncodedJSValue thisValue, PropertyName)
2366 {
2367     UNUSED_PARAM(state);
2368     UNUSED_PARAM(thisValue);
2369     JSValue decodedThisValue = JSValue::decode(thisValue);
2370     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2371     if (UNLIKELY(!castedThis)) {
2372         return throwGetterTypeError(*state, "TestObj", "id");
2373     }
2374     auto& impl = castedThis->wrapped();
2375     JSValue result = jsNumber(impl.id());
2376     return JSValue::encode(result);
2377 }
2378
2379
2380 EncodedJSValue jsTestObjHash(ExecState* state, EncodedJSValue thisValue, PropertyName)
2381 {
2382     UNUSED_PARAM(state);
2383     UNUSED_PARAM(thisValue);
2384     JSValue decodedThisValue = JSValue::decode(thisValue);
2385     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2386     if (UNLIKELY(!castedThis)) {
2387         return throwGetterTypeError(*state, "TestObj", "hash");
2388     }
2389     auto& impl = castedThis->wrapped();
2390     JSValue result = jsStringWithCache(state, impl.hash());
2391     return JSValue::encode(result);
2392 }
2393
2394
2395 EncodedJSValue jsTestObjReplaceableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2396 {
2397     UNUSED_PARAM(state);
2398     UNUSED_PARAM(thisValue);
2399     JSValue decodedThisValue = JSValue::decode(thisValue);
2400     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2401     if (UNLIKELY(!castedThis)) {
2402         return throwGetterTypeError(*state, "TestObj", "replaceableAttribute");
2403     }
2404     auto& impl = castedThis->wrapped();
2405     JSValue result = jsNumber(impl.replaceableAttribute());
2406     return JSValue::encode(result);
2407 }
2408
2409
2410 EncodedJSValue jsTestObjNullableDoubleAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2411 {
2412     UNUSED_PARAM(state);
2413     UNUSED_PARAM(thisValue);
2414     JSValue decodedThisValue = JSValue::decode(thisValue);
2415     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2416     if (UNLIKELY(!castedThis)) {
2417         return throwGetterTypeError(*state, "TestObj", "nullableDoubleAttribute");
2418     }
2419     auto& impl = castedThis->wrapped();
2420     JSValue result = toNullableJSNumber(impl.nullableDoubleAttribute());
2421     return JSValue::encode(result);
2422 }
2423
2424
2425 EncodedJSValue jsTestObjNullableLongAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2426 {
2427     UNUSED_PARAM(state);
2428     UNUSED_PARAM(thisValue);
2429     JSValue decodedThisValue = JSValue::decode(thisValue);
2430     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2431     if (UNLIKELY(!castedThis)) {
2432         return throwGetterTypeError(*state, "TestObj", "nullableLongAttribute");
2433     }
2434     auto& impl = castedThis->wrapped();
2435     JSValue result = toNullableJSNumber(impl.nullableLongAttribute());
2436     return JSValue::encode(result);
2437 }
2438
2439
2440 EncodedJSValue jsTestObjNullableBooleanAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2441 {
2442     UNUSED_PARAM(state);
2443     UNUSED_PARAM(thisValue);
2444     JSValue decodedThisValue = JSValue::decode(thisValue);
2445     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2446     if (UNLIKELY(!castedThis)) {
2447         return throwGetterTypeError(*state, "TestObj", "nullableBooleanAttribute");
2448     }
2449     auto& impl = castedThis->wrapped();
2450     JSValue result = jsBoolean(impl.nullableBooleanAttribute());
2451     return JSValue::encode(result);
2452 }
2453
2454
2455 EncodedJSValue jsTestObjNullableStringAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2456 {
2457     UNUSED_PARAM(state);
2458     UNUSED_PARAM(thisValue);
2459     JSValue decodedThisValue = JSValue::decode(thisValue);
2460     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2461     if (UNLIKELY(!castedThis)) {
2462         return throwGetterTypeError(*state, "TestObj", "nullableStringAttribute");
2463     }
2464     auto& impl = castedThis->wrapped();
2465     JSValue result = jsStringOrNull(state, impl.nullableStringAttribute());
2466     return JSValue::encode(result);
2467 }
2468
2469
2470 EncodedJSValue jsTestObjNullableLongSettableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2471 {
2472     UNUSED_PARAM(state);
2473     UNUSED_PARAM(thisValue);
2474     JSValue decodedThisValue = JSValue::decode(thisValue);
2475     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2476     if (UNLIKELY(!castedThis)) {
2477         return throwGetterTypeError(*state, "TestObj", "nullableLongSettableAttribute");
2478     }
2479     auto& impl = castedThis->wrapped();
2480     JSValue result = toNullableJSNumber(impl.nullableLongSettableAttribute());
2481     return JSValue::encode(result);
2482 }
2483
2484
2485 EncodedJSValue jsTestObjNullableStringSettableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2486 {
2487     UNUSED_PARAM(state);
2488     UNUSED_PARAM(thisValue);
2489     JSValue decodedThisValue = JSValue::decode(thisValue);
2490     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2491     if (UNLIKELY(!castedThis)) {
2492         return throwGetterTypeError(*state, "TestObj", "nullableStringSettableAttribute");
2493     }
2494     auto& impl = castedThis->wrapped();
2495     JSValue result = jsStringOrNull(state, impl.nullableStringSettableAttribute());
2496     return JSValue::encode(result);
2497 }
2498
2499
2500 EncodedJSValue jsTestObjNullableStringValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
2501 {
2502     UNUSED_PARAM(state);
2503     UNUSED_PARAM(thisValue);
2504     JSValue decodedThisValue = JSValue::decode(thisValue);
2505     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2506     if (UNLIKELY(!castedThis)) {
2507         return throwGetterTypeError(*state, "TestObj", "nullableStringValue");
2508     }
2509     ExceptionCode ec = 0;
2510     auto& impl = castedThis->wrapped();
2511     JSValue result = toNullableJSNumber(impl.nullableStringValue(ec));
2512     setDOMException(state, ec);
2513     return JSValue::encode(result);
2514 }
2515
2516
2517 EncodedJSValue jsTestObjAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2518 {
2519     UNUSED_PARAM(state);
2520     UNUSED_PARAM(thisValue);
2521     JSValue decodedThisValue = JSValue::decode(thisValue);
2522     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2523     if (UNLIKELY(!castedThis)) {
2524         return throwGetterTypeError(*state, "TestObj", "attribute");
2525     }
2526     auto& impl = castedThis->wrapped();
2527     JSValue result = jsStringWithCache(state, impl.attribute());
2528     return JSValue::encode(result);
2529 }
2530
2531
2532 EncodedJSValue jsTestObjAttributeWithReservedEnumType(ExecState* state, EncodedJSValue thisValue, PropertyName)
2533 {
2534     UNUSED_PARAM(state);
2535     UNUSED_PARAM(thisValue);
2536     JSValue decodedThisValue = JSValue::decode(thisValue);
2537     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2538     if (UNLIKELY(!castedThis)) {
2539         return throwGetterTypeError(*state, "TestObj", "attributeWithReservedEnumType");
2540     }
2541     auto& impl = castedThis->wrapped();
2542     JSValue result = jsStringWithCache(state, impl.attributeWithReservedEnumType());
2543     return JSValue::encode(result);
2544 }
2545
2546
2547 EncodedJSValue jsTestObjPutForwardsAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2548 {
2549     UNUSED_PARAM(state);
2550     UNUSED_PARAM(thisValue);
2551     JSValue decodedThisValue = JSValue::decode(thisValue);
2552     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2553     if (UNLIKELY(!castedThis)) {
2554         return throwGetterTypeError(*state, "TestObj", "putForwardsAttribute");
2555     }
2556     auto& impl = castedThis->wrapped();
2557     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.putForwardsAttribute()));
2558     return JSValue::encode(result);
2559 }
2560
2561
2562 EncodedJSValue jsTestObjPutForwardsNullableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2563 {
2564     UNUSED_PARAM(state);
2565     UNUSED_PARAM(thisValue);
2566     JSValue decodedThisValue = JSValue::decode(thisValue);
2567     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2568     if (UNLIKELY(!castedThis)) {
2569         return throwGetterTypeError(*state, "TestObj", "putForwardsNullableAttribute");
2570     }
2571     auto& impl = castedThis->wrapped();
2572     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.putForwardsNullableAttribute()));
2573     return JSValue::encode(result);
2574 }
2575
2576
2577 EncodedJSValue jsTestObjConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2578 {
2579     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue));
2580     if (UNLIKELY(!domObject))
2581         return throwVMTypeError(state);
2582     return JSValue::encode(JSTestObj::getConstructor(state->vm(), domObject->globalObject()));
2583 }
2584
2585 bool setJSTestObjConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2586 {
2587     JSValue value = JSValue::decode(encodedValue);
2588     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue));
2589     if (UNLIKELY(!domObject)) {
2590         throwVMTypeError(state);
2591         return false;
2592     }
2593     // Shadowing a built-in constructor
2594     return domObject->putDirect(state->vm(), state->propertyNames().constructor, value);
2595 }
2596
2597 bool setJSTestObjConstructorStaticStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2598 {
2599     JSValue value = JSValue::decode(encodedValue);
2600     auto nativeValue = value.toWTFString(state);
2601     if (UNLIKELY(state->hadException()))
2602         return false;
2603     TestObj::setStaticStringAttr(WTFMove(nativeValue));
2604     return true;
2605 }
2606
2607
2608 bool setJSTestObjTestSubObjEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2609 {
2610     JSValue value = JSValue::decode(encodedValue);
2611     UNUSED_PARAM(thisValue);
2612     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2613     if (UNLIKELY(!castedThis)) {
2614         return throwSetterTypeError(*state, "TestObj", "TestSubObjEnabledBySetting");
2615     }
2616     // Shadowing a built-in constructor.
2617     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "TestSubObjEnabledBySetting"), value);
2618 }
2619
2620
2621 bool setJSTestObjEnumAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2622 {
2623     JSValue value = JSValue::decode(encodedValue);
2624     UNUSED_PARAM(thisValue);
2625     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2626     if (UNLIKELY(!castedThis)) {
2627         return throwSetterTypeError(*state, "TestObj", "enumAttr");
2628     }
2629     auto& impl = castedThis->wrapped();
2630     auto nativeValue = parse<TestObj::EnumType>(*state, value);
2631     if (UNLIKELY(state->hadException()))
2632         return false;
2633     if (UNLIKELY(!nativeValue))
2634         return false;
2635     impl.setEnumAttr(nativeValue.value());
2636     return true;
2637 }
2638
2639
2640 bool setJSTestObjByteAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2641 {
2642     JSValue value = JSValue::decode(encodedValue);
2643     UNUSED_PARAM(thisValue);
2644     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2645     if (UNLIKELY(!castedThis)) {
2646         return throwSetterTypeError(*state, "TestObj", "byteAttr");
2647     }
2648     auto& impl = castedThis->wrapped();
2649     auto nativeValue = toInt8(state, value, NormalConversion);
2650     if (UNLIKELY(state->hadException()))
2651         return false;
2652     impl.setByteAttr(WTFMove(nativeValue));
2653     return true;
2654 }
2655
2656
2657 bool setJSTestObjOctetAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2658 {
2659     JSValue value = JSValue::decode(encodedValue);
2660     UNUSED_PARAM(thisValue);
2661     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2662     if (UNLIKELY(!castedThis)) {
2663         return throwSetterTypeError(*state, "TestObj", "octetAttr");
2664     }
2665     auto& impl = castedThis->wrapped();
2666     auto nativeValue = toUInt8(state, value, NormalConversion);
2667     if (UNLIKELY(state->hadException()))
2668         return false;
2669     impl.setOctetAttr(WTFMove(nativeValue));
2670     return true;
2671 }
2672
2673
2674 bool setJSTestObjShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2675 {
2676     JSValue value = JSValue::decode(encodedValue);
2677     UNUSED_PARAM(thisValue);
2678     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2679     if (UNLIKELY(!castedThis)) {
2680         return throwSetterTypeError(*state, "TestObj", "shortAttr");
2681     }
2682     auto& impl = castedThis->wrapped();
2683     auto nativeValue = toInt16(state, value, NormalConversion);
2684     if (UNLIKELY(state->hadException()))
2685         return false;
2686     impl.setShortAttr(WTFMove(nativeValue));
2687     return true;
2688 }
2689
2690
2691 bool setJSTestObjClampedShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2692 {
2693     JSValue value = JSValue::decode(encodedValue);
2694     UNUSED_PARAM(thisValue);
2695     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2696     if (UNLIKELY(!castedThis)) {
2697         return throwSetterTypeError(*state, "TestObj", "clampedShortAttr");
2698     }
2699     auto& impl = castedThis->wrapped();
2700     auto nativeValue = toInt16(state, value, Clamp);
2701     if (UNLIKELY(state->hadException()))
2702         return false;
2703     impl.setClampedShortAttr(WTFMove(nativeValue));
2704     return true;
2705 }
2706
2707
2708 bool setJSTestObjEnforceRangeShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2709 {
2710     JSValue value = JSValue::decode(encodedValue);
2711     UNUSED_PARAM(thisValue);
2712     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2713     if (UNLIKELY(!castedThis)) {
2714         return throwSetterTypeError(*state, "TestObj", "enforceRangeShortAttr");
2715     }
2716     auto& impl = castedThis->wrapped();
2717     auto nativeValue = toInt16(state, value, EnforceRange);
2718     if (UNLIKELY(state->hadException()))
2719         return false;
2720     impl.setEnforceRangeShortAttr(WTFMove(nativeValue));
2721     return true;
2722 }
2723
2724
2725 bool setJSTestObjUnsignedShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2726 {
2727     JSValue value = JSValue::decode(encodedValue);
2728     UNUSED_PARAM(thisValue);
2729     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2730     if (UNLIKELY(!castedThis)) {
2731         return throwSetterTypeError(*state, "TestObj", "unsignedShortAttr");
2732     }
2733     auto& impl = castedThis->wrapped();
2734     auto nativeValue = toUInt16(state, value, NormalConversion);
2735     if (UNLIKELY(state->hadException()))
2736         return false;
2737     impl.setUnsignedShortAttr(WTFMove(nativeValue));
2738     return true;
2739 }
2740
2741
2742 bool setJSTestObjLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2743 {
2744     JSValue value = JSValue::decode(encodedValue);
2745     UNUSED_PARAM(thisValue);
2746     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2747     if (UNLIKELY(!castedThis)) {
2748         return throwSetterTypeError(*state, "TestObj", "longAttr");
2749     }
2750     auto& impl = castedThis->wrapped();
2751     auto nativeValue = toInt32(state, value, NormalConversion);
2752     if (UNLIKELY(state->hadException()))
2753         return false;
2754     impl.setLongAttr(WTFMove(nativeValue));
2755     return true;
2756 }
2757
2758
2759 bool setJSTestObjLongLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2760 {
2761     JSValue value = JSValue::decode(encodedValue);
2762     UNUSED_PARAM(thisValue);
2763     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2764     if (UNLIKELY(!castedThis)) {
2765         return throwSetterTypeError(*state, "TestObj", "longLongAttr");
2766     }
2767     auto& impl = castedThis->wrapped();
2768     auto nativeValue = toInt64(state, value, NormalConversion);
2769     if (UNLIKELY(state->hadException()))
2770         return false;
2771     impl.setLongLongAttr(WTFMove(nativeValue));
2772     return true;
2773 }
2774
2775
2776 bool setJSTestObjUnsignedLongLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2777 {
2778     JSValue value = JSValue::decode(encodedValue);
2779     UNUSED_PARAM(thisValue);
2780     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2781     if (UNLIKELY(!castedThis)) {
2782         return throwSetterTypeError(*state, "TestObj", "unsignedLongLongAttr");
2783     }
2784     auto& impl = castedThis->wrapped();
2785     auto nativeValue = toUInt64(state, value, NormalConversion);
2786     if (UNLIKELY(state->hadException()))
2787         return false;
2788     impl.setUnsignedLongLongAttr(WTFMove(nativeValue));
2789     return true;
2790 }
2791
2792
2793 bool setJSTestObjStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2794 {
2795     JSValue value = JSValue::decode(encodedValue);
2796     UNUSED_PARAM(thisValue);
2797     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2798     if (UNLIKELY(!castedThis)) {
2799         return throwSetterTypeError(*state, "TestObj", "stringAttr");
2800     }
2801     auto& impl = castedThis->wrapped();
2802     auto nativeValue = value.toWTFString(state);
2803     if (UNLIKELY(state->hadException()))
2804         return false;
2805     impl.setStringAttr(WTFMove(nativeValue));
2806     return true;
2807 }
2808
2809
2810 bool setJSTestObjTestObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2811 {
2812     JSValue value = JSValue::decode(encodedValue);
2813     UNUSED_PARAM(thisValue);
2814     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2815     if (UNLIKELY(!castedThis)) {
2816         return throwSetterTypeError(*state, "TestObj", "testObjAttr");
2817     }
2818     auto& impl = castedThis->wrapped();
2819     auto nativeValue = JSTestObj::toWrapped(value);
2820     if (UNLIKELY(!nativeValue)) {
2821         throwVMTypeError(state);
2822         return false;
2823     }
2824     impl.setTestObjAttr(*nativeValue);
2825     return true;
2826 }
2827
2828
2829 bool setJSTestObjTestNullableObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2830 {
2831     JSValue value = JSValue::decode(encodedValue);
2832     UNUSED_PARAM(thisValue);
2833     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2834     if (UNLIKELY(!castedThis)) {
2835         return throwSetterTypeError(*state, "TestObj", "testNullableObjAttr");
2836     }
2837     auto& impl = castedThis->wrapped();
2838     auto nativeValue = JSTestObj::toWrapped(value);
2839     impl.setTestNullableObjAttr(WTFMove(nativeValue));
2840     return true;
2841 }
2842
2843
2844 bool setJSTestObjLenientTestObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2845 {
2846     JSValue value = JSValue::decode(encodedValue);
2847     UNUSED_PARAM(thisValue);
2848     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2849     if (UNLIKELY(!castedThis)) {
2850         return false;
2851     }
2852     auto& impl = castedThis->wrapped();
2853     auto nativeValue = JSTestObj::toWrapped(value);
2854     if (UNLIKELY(!nativeValue)) {
2855         throwVMTypeError(state);
2856         return false;
2857     }
2858     impl.setLenientTestObjAttr(*nativeValue);
2859     return true;
2860 }
2861
2862
2863 bool setJSTestObjStringAttrTreatingNullAsEmptyString(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2864 {
2865     JSValue value = JSValue::decode(encodedValue);
2866     UNUSED_PARAM(thisValue);
2867     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2868     if (UNLIKELY(!castedThis)) {
2869         return throwSetterTypeError(*state, "TestObj", "stringAttrTreatingNullAsEmptyString");
2870     }
2871     auto& impl = castedThis->wrapped();
2872     auto nativeValue = valueToStringTreatingNullAsEmptyString(state, value);
2873     if (UNLIKELY(state->hadException()))
2874         return false;
2875     impl.setStringAttrTreatingNullAsEmptyString(WTFMove(nativeValue));
2876     return true;
2877 }
2878
2879
2880 bool setJSTestObjXMLObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2881 {
2882     JSValue value = JSValue::decode(encodedValue);
2883     UNUSED_PARAM(thisValue);
2884     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2885     if (UNLIKELY(!castedThis)) {
2886         return throwSetterTypeError(*state, "TestObj", "XMLObjAttr");
2887     }
2888     auto& impl = castedThis->wrapped();
2889     auto nativeValue = JSTestObj::toWrapped(value);
2890     if (UNLIKELY(!nativeValue)) {
2891         throwVMTypeError(state);
2892         return false;
2893     }
2894     impl.setXMLObjAttr(*nativeValue);
2895     return true;
2896 }
2897
2898
2899 bool setJSTestObjCreate(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2900 {
2901     JSValue value = JSValue::decode(encodedValue);
2902     UNUSED_PARAM(thisValue);
2903     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2904     if (UNLIKELY(!castedThis)) {
2905         return throwSetterTypeError(*state, "TestObj", "create");
2906     }
2907     auto& impl = castedThis->wrapped();
2908     auto nativeValue = value.toBoolean(state);
2909     if (UNLIKELY(state->hadException()))
2910         return false;
2911     impl.setCreate(WTFMove(nativeValue));
2912     return true;
2913 }
2914
2915
2916 bool setJSTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2917 {
2918     JSValue value = JSValue::decode(encodedValue);
2919     UNUSED_PARAM(thisValue);
2920     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2921     if (UNLIKELY(!castedThis)) {
2922         return throwSetterTypeError(*state, "TestObj", "reflectedStringAttr");
2923     }
2924     auto& impl = castedThis->wrapped();
2925     auto nativeValue = value.toWTFString(state);
2926     if (UNLIKELY(state->hadException()))
2927         return false;
2928     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedstringattrAttr, WTFMove(nativeValue));
2929     return true;
2930 }
2931
2932
2933 bool setJSTestObjReflectedIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2934 {
2935     JSValue value = JSValue::decode(encodedValue);
2936     UNUSED_PARAM(thisValue);
2937     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2938     if (UNLIKELY(!castedThis)) {
2939         return throwSetterTypeError(*state, "TestObj", "reflectedIntegralAttr");
2940     }
2941     auto& impl = castedThis->wrapped();
2942     auto nativeValue = toInt32(state, value, NormalConversion);
2943     if (UNLIKELY(state->hadException()))
2944         return false;
2945     impl.setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, WTFMove(nativeValue));
2946     return true;
2947 }
2948
2949
2950 bool setJSTestObjReflectedUnsignedIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2951 {
2952     JSValue value = JSValue::decode(encodedValue);
2953     UNUSED_PARAM(thisValue);
2954     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2955     if (UNLIKELY(!castedThis)) {
2956         return throwSetterTypeError(*state, "TestObj", "reflectedUnsignedIntegralAttr");
2957     }
2958     auto& impl = castedThis->wrapped();
2959     auto nativeValue = toUInt32(state, value, NormalConversion);
2960     if (UNLIKELY(state->hadException()))
2961         return false;
2962     impl.setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, WTFMove(nativeValue));
2963     return true;
2964 }
2965
2966
2967 bool setJSTestObjReflectedBooleanAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2968 {
2969     JSValue value = JSValue::decode(encodedValue);
2970     UNUSED_PARAM(thisValue);
2971     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2972     if (UNLIKELY(!castedThis)) {
2973         return throwSetterTypeError(*state, "TestObj", "reflectedBooleanAttr");
2974     }
2975     auto& impl = castedThis->wrapped();
2976     auto nativeValue = value.toBoolean(state);
2977     if (UNLIKELY(state->hadException()))
2978         return false;
2979     impl.setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, WTFMove(nativeValue));
2980     return true;
2981 }
2982
2983
2984 bool setJSTestObjReflectedURLAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2985 {
2986     JSValue value = JSValue::decode(encodedValue);
2987     UNUSED_PARAM(thisValue);
2988     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2989     if (UNLIKELY(!castedThis)) {
2990         return throwSetterTypeError(*state, "TestObj", "reflectedURLAttr");
2991     }
2992     auto& impl = castedThis->wrapped();
2993     auto nativeValue = value.toWTFString(state);
2994     if (UNLIKELY(state->hadException()))
2995         return false;
2996     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedurlattrAttr, WTFMove(nativeValue));
2997     return true;
2998 }
2999
3000
3001 bool setJSTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3002 {
3003     JSValue value = JSValue::decode(encodedValue);
3004     UNUSED_PARAM(thisValue);
3005     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3006     if (UNLIKELY(!castedThis)) {
3007         return throwSetterTypeError(*state, "TestObj", "reflectedStringAttr");
3008     }
3009     auto& impl = castedThis->wrapped();
3010     auto nativeValue = value.toWTFString(state);
3011     if (UNLIKELY(state->hadException()))
3012         return false;
3013     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentStringAttrAttr, WTFMove(nativeValue));
3014     return true;
3015 }
3016
3017
3018 bool setJSTestObjReflectedCustomIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3019 {
3020     JSValue value = JSValue::decode(encodedValue);
3021     UNUSED_PARAM(thisValue);
3022     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3023     if (UNLIKELY(!castedThis)) {
3024         return throwSetterTypeError(*state, "TestObj", "reflectedCustomIntegralAttr");
3025     }
3026     auto& impl = castedThis->wrapped();
3027     auto nativeValue = toInt32(state, value, NormalConversion);
3028     if (UNLIKELY(state->hadException()))
3029         return false;
3030     impl.setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, WTFMove(nativeValue));
3031     return true;
3032 }
3033
3034
3035 bool setJSTestObjReflectedCustomBooleanAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3036 {
3037     JSValue value = JSValue::decode(encodedValue);
3038     UNUSED_PARAM(thisValue);
3039     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3040     if (UNLIKELY(!castedThis)) {
3041         return throwSetterTypeError(*state, "TestObj", "reflectedCustomBooleanAttr");
3042     }
3043     auto& impl = castedThis->wrapped();
3044     auto nativeValue = value.toBoolean(state);
3045     if (UNLIKELY(state->hadException()))
3046         return false;
3047     impl.setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, WTFMove(nativeValue));
3048     return true;
3049 }
3050
3051
3052 bool setJSTestObjReflectedCustomURLAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3053 {
3054     JSValue value = JSValue::decode(encodedValue);
3055     UNUSED_PARAM(thisValue);
3056     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3057     if (UNLIKELY(!castedThis)) {
3058         return throwSetterTypeError(*state, "TestObj", "reflectedCustomURLAttr");
3059     }
3060     auto& impl = castedThis->wrapped();
3061     auto nativeValue = value.toWTFString(state);
3062     if (UNLIKELY(state->hadException()))
3063         return false;
3064     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentURLAttrAttr, WTFMove(nativeValue));
3065     return true;
3066 }
3067
3068
3069 #if ENABLE(TEST_FEATURE)
3070 bool setJSTestObjEnabledAtRuntimeAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3071 {
3072     JSValue value = JSValue::decode(encodedValue);
3073     UNUSED_PARAM(thisValue);
3074     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3075     if (UNLIKELY(!castedThis)) {
3076         return throwSetterTypeError(*state, "TestObj", "enabledAtRuntimeAttribute");
3077     }
3078     auto& impl = castedThis->wrapped();
3079     auto nativeValue = value.toWTFString(state);
3080     if (UNLIKELY(state->hadException()))
3081         return false;
3082     impl.setEnabledAtRuntimeAttribute(WTFMove(nativeValue));
3083     return true;
3084 }
3085
3086 #endif
3087
3088 bool setJSTestObjTypedArrayAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3089 {
3090     JSValue value = JSValue::decode(encodedValue);
3091     UNUSED_PARAM(thisValue);
3092     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3093     if (UNLIKELY(!castedThis)) {
3094         return throwSetterTypeError(*state, "TestObj", "typedArrayAttr");
3095     }
3096     auto& impl = castedThis->wrapped();
3097     auto nativeValue = toFloat32Array(value);
3098     if (UNLIKELY(state->hadException()))
3099         return false;
3100     if (UNLIKELY(!nativeValue)) {
3101         throwVMTypeError(state);
3102         return false;
3103     }
3104     impl.setTypedArrayAttr(nativeValue.get());
3105     return true;
3106 }
3107
3108
3109 bool setJSTestObjAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3110 {
3111     JSValue value = JSValue::decode(encodedValue);
3112     UNUSED_PARAM(thisValue);
3113     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3114     if (UNLIKELY(!castedThis)) {
3115         return throwSetterTypeError(*state, "TestObj", "attrWithGetterException");
3116     }
3117     auto& impl = castedThis->wrapped();
3118     auto nativeValue = toInt32(state, value, NormalConversion);
3119     if (UNLIKELY(state->hadException()))
3120         return false;
3121     impl.setAttrWithGetterException(WTFMove(nativeValue));
3122     return true;
3123 }
3124
3125
3126 bool setJSTestObjAttrWithGetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3127 {
3128     JSValue value = JSValue::decode(encodedValue);
3129     UNUSED_PARAM(thisValue);
3130     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3131     if (UNLIKELY(!castedThis)) {
3132         return throwSetterTypeError(*state, "TestObj", "attrWithGetterExceptionWithMessage");
3133     }
3134     auto& impl = castedThis->wrapped();
3135     auto nativeValue = toInt32(state, value, NormalConversion);
3136     if (UNLIKELY(state->hadException()))
3137         return false;
3138     impl.setAttrWithGetterExceptionWithMessage(WTFMove(nativeValue));
3139     return true;
3140 }
3141
3142
3143 bool setJSTestObjAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3144 {
3145     JSValue value = JSValue::decode(encodedValue);
3146     UNUSED_PARAM(thisValue);
3147     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3148     if (UNLIKELY(!castedThis)) {
3149         return throwSetterTypeError(*state, "TestObj", "attrWithSetterException");
3150     }
3151     auto& impl = castedThis->wrapped();
3152     ExceptionCode ec = 0;
3153     auto nativeValue = toInt32(state, value, NormalConversion);
3154     if (UNLIKELY(state->hadException()))
3155         return false;
3156     impl.setAttrWithSetterException(WTFMove(nativeValue), ec);
3157     setDOMException(state, ec);
3158     return true;
3159 }
3160
3161
3162 bool setJSTestObjAttrWithSetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3163 {
3164     JSValue value = JSValue::decode(encodedValue);
3165     UNUSED_PARAM(thisValue);
3166     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3167     if (UNLIKELY(!castedThis)) {
3168         return throwSetterTypeError(*state, "TestObj", "attrWithSetterExceptionWithMessage");
3169     }
3170     auto& impl = castedThis->wrapped();
3171     ExceptionCodeWithMessage ec;
3172     auto nativeValue = toInt32(state, value, NormalConversion);
3173     if (UNLIKELY(state->hadException()))
3174         return false;
3175     impl.setAttrWithSetterExceptionWithMessage(WTFMove(nativeValue), ec);
3176     setDOMException(state, ec);
3177     return true;
3178 }
3179
3180
3181 bool setJSTestObjStringAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3182 {
3183     JSValue value = JSValue::decode(encodedValue);
3184     UNUSED_PARAM(thisValue);
3185     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3186     if (UNLIKELY(!castedThis)) {
3187         return throwSetterTypeError(*state, "TestObj", "stringAttrWithGetterException");
3188     }
3189     auto& impl = castedThis->wrapped();
3190     auto nativeValue = value.toWTFString(state);
3191     if (UNLIKELY(state->hadException()))
3192         return false;
3193     impl.setStringAttrWithGetterException(WTFMove(nativeValue));
3194     return true;
3195 }
3196
3197
3198 bool setJSTestObjStringAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3199 {
3200     JSValue value = JSValue::decode(encodedValue);
3201     UNUSED_PARAM(thisValue);
3202     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3203     if (UNLIKELY(!castedThis)) {
3204         return throwSetterTypeError(*state, "TestObj", "stringAttrWithSetterException");
3205     }
3206     auto& impl = castedThis->wrapped();
3207     ExceptionCode ec = 0;
3208     auto nativeValue = value.toWTFString(state);
3209     if (UNLIKELY(state->hadException()))
3210         return false;
3211     impl.setStringAttrWithSetterException(WTFMove(nativeValue), ec);
3212     setDOMException(state, ec);
3213     return true;
3214 }
3215
3216
3217 bool setJSTestObjStrictTypeCheckingAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3218 {
3219     JSValue value = JSValue::decode(encodedValue);
3220     UNUSED_PARAM(thisValue);
3221     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3222     if (UNLIKELY(!castedThis)) {
3223         return throwSetterTypeError(*state, "TestObj", "strictTypeCheckingAttribute");
3224     }
3225     auto& impl = castedThis->wrapped();
3226     TestObj* nativeValue = nullptr;
3227     if (!value.isUndefinedOrNull()) {
3228         nativeValue = JSTestObj::toWrapped(value);
3229         if (UNLIKELY(!nativeValue)) {
3230             throwAttributeTypeError(*state, "TestObj", "strictTypeCheckingAttribute", "TestObj");
3231             return false;
3232         }
3233     }
3234     impl.setStrictTypeCheckingAttribute(WTFMove(nativeValue));
3235     return true;
3236 }
3237
3238
3239 bool setJSTestObjCustomAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3240 {
3241     JSValue value = JSValue::decode(encodedValue);
3242     UNUSED_PARAM(thisValue);
3243     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3244     if (UNLIKELY(!castedThis)) {
3245         return throwSetterTypeError(*state, "TestObj", "customAttr");
3246     }
3247     castedThis->setCustomAttr(*state, value);
3248     return true;
3249 }
3250
3251
3252 bool setJSTestObjOnfoo(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3253 {
3254     JSValue value = JSValue::decode(encodedValue);
3255     UNUSED_PARAM(thisValue);
3256     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3257     if (UNLIKELY(!castedThis)) {
3258         return throwSetterTypeError(*state, "TestObj", "onfoo");
3259     }
3260     setEventHandlerAttribute(*state, *castedThis, castedThis->wrapped(), eventNames().fooEvent, value);
3261     return true;
3262 }
3263
3264
3265 bool setJSTestObjOnwebkitfoo(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3266 {
3267     JSValue value = JSValue::decode(encodedValue);
3268     UNUSED_PARAM(thisValue);
3269     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3270     if (UNLIKELY(!castedThis)) {
3271         return throwSetterTypeError(*state, "TestObj", "onwebkitfoo");
3272     }
3273     setEventHandlerAttribute(*state, *castedThis, castedThis->wrapped(), eventNames().fooEvent, value);
3274     return true;
3275 }
3276
3277
3278 bool setJSTestObjWithScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3279 {
3280     JSValue value = JSValue::decode(encodedValue);
3281     UNUSED_PARAM(thisValue);
3282     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3283     if (UNLIKELY(!castedThis)) {
3284         return throwSetterTypeError(*state, "TestObj", "withScriptStateAttribute");
3285     }
3286     auto& impl = castedThis->wrapped();
3287     auto nativeValue = toInt32(state, value, NormalConversion);
3288     if (UNLIKELY(state->hadException()))
3289         return false;
3290     impl.setWithScriptStateAttribute(*state, WTFMove(nativeValue));
3291     return true;
3292 }
3293
3294
3295 bool setJSTestObjWithCallWithAndSetterCallWithAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3296 {
3297     JSValue value = JSValue::decode(encodedValue);
3298     UNUSED_PARAM(thisValue);
3299     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3300     if (UNLIKELY(!castedThis)) {
3301         return throwSetterTypeError(*state, "TestObj", "withCallWithAndSetterCallWithAttribute");
3302     }
3303     auto& impl = castedThis->wrapped();
3304     auto nativeValue = toInt32(state, value, NormalConversion);
3305     if (UNLIKELY(state->hadException()))
3306         return false;
3307     impl.setWithCallWithAndSetterCallWithAttribute(*state, activeDOMWindow(state), firstDOMWindow(state), WTFMove(nativeValue));
3308     return true;
3309 }
3310
3311
3312 bool setJSTestObjWithScriptExecutionContextAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3313 {
3314     JSValue value = JSValue::decode(encodedValue);
3315     UNUSED_PARAM(thisValue);
3316     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3317     if (UNLIKELY(!castedThis)) {
3318         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAttribute");
3319     }
3320     auto& impl = castedThis->wrapped();
3321     auto nativeValue = JSTestObj::toWrapped(value);
3322     if (UNLIKELY(!nativeValue)) {
3323         throwVMTypeError(state);
3324         return false;
3325     }
3326     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3327     if (!context)
3328         return false;
3329     impl.setWithScriptExecutionContextAttribute(*context, *nativeValue);
3330     return true;
3331 }
3332
3333
3334 bool setJSTestObjWithScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3335 {
3336     JSValue value = JSValue::decode(encodedValue);
3337     UNUSED_PARAM(thisValue);
3338     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3339     if (UNLIKELY(!castedThis)) {
3340         return throwSetterTypeError(*state, "TestObj", "withScriptStateAttributeRaises");
3341     }
3342     auto& impl = castedThis->wrapped();
3343     auto nativeValue = JSTestObj::toWrapped(value);
3344     if (UNLIKELY(!nativeValue)) {
3345         throwVMTypeError(state);
3346         return false;
3347     }
3348     impl.setWithScriptStateAttributeRaises(*state, *nativeValue);
3349     return true;
3350 }
3351
3352
3353 bool setJSTestObjWithScriptExecutionContextAttributeRaises(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3354 {
3355     JSValue value = JSValue::decode(encodedValue);
3356     UNUSED_PARAM(thisValue);
3357     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3358     if (UNLIKELY(!castedThis)) {
3359         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAttributeRaises");
3360     }
3361     auto& impl = castedThis->wrapped();
3362     auto nativeValue = JSTestObj::toWrapped(value);
3363     if (UNLIKELY(!nativeValue)) {
3364         throwVMTypeError(state);
3365         return false;
3366     }
3367     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3368     if (!context)
3369         return false;
3370     impl.setWithScriptExecutionContextAttributeRaises(*context, *nativeValue);
3371     return true;
3372 }
3373
3374
3375 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3376 {
3377     JSValue value = JSValue::decode(encodedValue);
3378     UNUSED_PARAM(thisValue);
3379     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3380     if (UNLIKELY(!castedThis)) {
3381         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
3382     }
3383     auto& impl = castedThis->wrapped();
3384     auto nativeValue = JSTestObj::toWrapped(value);
3385     if (UNLIKELY(!nativeValue)) {
3386         throwVMTypeError(state);
3387         return false;
3388     }
3389     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3390     if (!context)
3391         return false;
3392     impl.setWithScriptExecutionContextAndScriptStateAttribute(*state, *context, *nativeValue);
3393     return true;
3394 }
3395
3396
3397 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3398 {
3399     JSValue value = JSValue::decode(encodedValue);
3400     UNUSED_PARAM(thisValue);
3401     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3402     if (UNLIKELY(!castedThis)) {
3403         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
3404     }
3405     auto& impl = castedThis->wrapped();
3406     auto nativeValue = JSTestObj::toWrapped(value);
3407     if (UNLIKELY(!nativeValue)) {
3408         throwVMTypeError(state);
3409         return false;
3410     }
3411     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3412     if (!context)
3413         return false;
3414     impl.setWithScriptExecutionContextAndScriptStateAttributeRaises(*state, *context, *nativeValue);
3415     return true;
3416 }
3417
3418
3419 bool setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3420 {
3421     JSValue value = JSValue::decode(encodedValue);
3422     UNUSED_PARAM(thisValue);
3423     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3424     if (UNLIKELY(!castedThis)) {
3425         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
3426     }
3427     auto& impl = castedThis->wrapped();
3428     auto nativeValue = JSTestObj::toWrapped(value);
3429     if (UNLIKELY(!nativeValue)) {
3430         throwVMTypeError(state);
3431         return false;
3432     }
3433     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3434     if (!context)
3435         return false;
3436     impl.setWithScriptExecutionContextAndScriptStateWithSpacesAttribute(*state, *context, *nativeValue);
3437     return true;
3438 }
3439
3440
3441 bool setJSTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3442 {
3443     JSValue value = JSValue::decode(encodedValue);
3444     UNUSED_PARAM(thisValue);
3445     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3446     if (UNLIKELY(!castedThis)) {
3447         return throwSetterTypeError(*state, "TestObj", "withScriptArgumentsAndCallStackAttribute");
3448     }
3449     auto& impl = castedThis->wrapped();
3450     auto nativeValue = JSTestObj::toWrapped(value);
3451     if (UNLIKELY(!nativeValue)) {
3452         throwVMTypeError(state);
3453         return false;
3454     }
3455     impl.setWithScriptArgumentsAndCallStackAttribute(*nativeValue);
3456     return true;
3457 }
3458
3459
3460 #if ENABLE(Condition1)
3461 bool setJSTestObjConditionalAttr1(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3462 {
3463     JSValue value = JSValue::decode(encodedValue);
3464     UNUSED_PARAM(thisValue);
3465     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3466     if (UNLIKELY(!castedThis)) {
3467         return throwSetterTypeError(*state, "TestObj", "conditionalAttr1");
3468     }
3469     auto& impl = castedThis->wrapped();
3470     auto nativeValue = toInt32(state, value, NormalConversion);
3471     if (UNLIKELY(state->hadException()))
3472         return false;
3473     impl.setConditionalAttr1(WTFMove(nativeValue));
3474     return true;
3475 }
3476
3477 #endif
3478
3479 #if ENABLE(Condition1) && ENABLE(Condition2)
3480 bool setJSTestObjConditionalAttr2(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3481 {
3482     JSValue value = JSValue::decode(encodedValue);
3483     UNUSED_PARAM(thisValue);
3484     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3485     if (UNLIKELY(!castedThis)) {
3486         return throwSetterTypeError(*state, "TestObj", "conditionalAttr2");
3487     }
3488     auto& impl = castedThis->wrapped();
3489     auto nativeValue = toInt32(state, value, NormalConversion);
3490     if (UNLIKELY(state->hadException()))
3491         return false;
3492     impl.setConditionalAttr2(WTFMove(nativeValue));
3493     return true;
3494 }
3495
3496 #endif
3497
3498 #if ENABLE(Condition1) || ENABLE(Condition2)
3499 bool setJSTestObjConditionalAttr3(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3500 {
3501     JSValue value = JSValue::decode(encodedValue);
3502     UNUSED_PARAM(thisValue);
3503     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3504     if (UNLIKELY(!castedThis)) {
3505         return throwSetterTypeError(*state, "TestObj", "conditionalAttr3");
3506     }
3507     auto& impl = castedThis->wrapped();
3508     auto nativeValue = toInt32(state, value, NormalConversion);
3509     if (UNLIKELY(state->hadException()))
3510         return false;
3511     impl.setConditionalAttr3(WTFMove(nativeValue));
3512     return true;
3513 }
3514
3515 #endif
3516
3517 #if ENABLE(Condition1)
3518 bool setJSTestObjConditionalAttr4Constructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3519 {
3520     JSValue value = JSValue::decode(encodedValue);
3521     UNUSED_PARAM(thisValue);
3522     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3523     if (UNLIKELY(!castedThis)) {
3524         return throwSetterTypeError(*state, "TestObj", "conditionalAttr4");
3525     }
3526     // Shadowing a built-in constructor.
3527     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "conditionalAttr4"), value);
3528 }
3529
3530 #endif
3531
3532 #if ENABLE(Condition1) && ENABLE(Condition2)
3533 bool setJSTestObjConditionalAttr5Constructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3534 {
3535     JSValue value = JSValue::decode(encodedValue);
3536     UNUSED_PARAM(thisValue);
3537     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3538     if (UNLIKELY(!castedThis)) {
3539         return throwSetterTypeError(*state, "TestObj", "conditionalAttr5");
3540     }
3541     // Shadowing a built-in constructor.
3542     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "conditionalAttr5"), value);
3543 }
3544
3545 #endif
3546
3547 #if ENABLE(Condition1) || ENABLE(Condition2)
3548 bool setJSTestObjConditionalAttr6Constructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3549 {
3550     JSValue value = JSValue::decode(encodedValue);
3551     UNUSED_PARAM(thisValue);
3552     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3553     if (UNLIKELY(!castedThis)) {
3554         return throwSetterTypeError(*state, "TestObj", "conditionalAttr6");
3555     }
3556     // Shadowing a built-in constructor.
3557     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "conditionalAttr6"), value);
3558 }
3559
3560 #endif
3561
3562 bool setJSTestObjAnyAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3563 {
3564     JSValue value = JSValue::decode(encodedValue);
3565     UNUSED_PARAM(thisValue);
3566     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3567     if (UNLIKELY(!castedThis)) {
3568         return throwSetterTypeError(*state, "TestObj", "anyAttribute");
3569     }
3570     auto& impl = castedThis->wrapped();
3571     auto nativeValue = value;
3572     impl.setAnyAttribute(WTFMove(nativeValue));
3573     return true;
3574 }
3575
3576
3577 bool setJSTestObjMutablePoint(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3578 {
3579     JSValue value = JSValue::decode(encodedValue);
3580     UNUSED_PARAM(thisValue);
3581     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3582     if (UNLIKELY(!castedThis)) {
3583         return throwSetterTypeError(*state, "TestObj", "mutablePoint");
3584     }
3585     auto& impl = castedThis->wrapped();
3586     auto nativeValue = JSSVGPoint::toWrapped(value);
3587     impl.setMutablePoint(WTFMove(nativeValue));
3588     return true;
3589 }
3590
3591
3592 bool setJSTestObjImmutablePoint(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3593 {
3594     JSValue value = JSValue::decode(encodedValue);
3595     UNUSED_PARAM(thisValue);
3596     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3597     if (UNLIKELY(!castedThis)) {
3598         return throwSetterTypeError(*state, "TestObj", "immutablePoint");
3599     }
3600     auto& impl = castedThis->wrapped();
3601     auto nativeValue = JSSVGPoint::toWrapped(value);
3602     impl.setImmutablePoint(WTFMove(nativeValue));
3603     return true;
3604 }
3605
3606
3607 bool setJSTestObjStrawberry(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3608 {
3609     JSValue value = JSValue::decode(encodedValue);
3610     UNUSED_PARAM(thisValue);
3611     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3612     if (UNLIKELY(!castedThis)) {
3613         return throwSetterTypeError(*state, "TestObj", "strawberry");
3614     }
3615     auto& impl = castedThis->wrapped();
3616     auto nativeValue = toInt32(state, value, NormalConversion);
3617     if (UNLIKELY(state->hadException()))
3618         return false;
3619     impl.setBlueberry(WTFMove(nativeValue));
3620     return true;
3621 }
3622
3623
3624 bool setJSTestObjStrictFloat(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3625 {
3626     JSValue value = JSValue::decode(encodedValue);
3627     UNUSED_PARAM(thisValue);
3628     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3629     if (UNLIKELY(!castedThis)) {
3630         return throwSetterTypeError(*state, "TestObj", "strictFloat");
3631     }
3632     auto& impl = castedThis->wrapped();
3633     auto nativeValue = build<float>(*state, value, ShouldAllowNonFinite::Yes);
3634     if (UNLIKELY(state->hadException()))
3635         return false;
3636     impl.setStrictFloat(WTFMove(nativeValue));
3637     return true;
3638 }
3639
3640
3641 bool setJSTestObjId(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3642 {
3643     JSValue value = JSValue::decode(encodedValue);
3644     UNUSED_PARAM(thisValue);
3645     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3646     if (UNLIKELY(!castedThis)) {
3647         return throwSetterTypeError(*state, "TestObj", "id");
3648     }
3649     auto& impl = castedThis->wrapped();
3650     auto nativeValue = toInt32(state, value, NormalConversion);
3651     if (UNLIKELY(state->hadException()))
3652         return false;
3653     impl.setId(WTFMove(nativeValue));
3654     return true;
3655 }
3656
3657
3658 bool setJSTestObjReplaceableAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3659 {
3660     JSValue value = JSValue::decode(encodedValue);
3661     UNUSED_PARAM(thisValue);
3662     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3663     if (UNLIKELY(!castedThis)) {
3664         return throwSetterTypeError(*state, "TestObj", "replaceableAttribute");
3665     }
3666     // Shadowing a built-in object.
3667     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "replaceableAttribute"), value);
3668 }
3669
3670
3671 bool setJSTestObjNullableLongSettableAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3672 {
3673     JSValue value = JSValue::decode(encodedValue);
3674     UNUSED_PARAM(thisValue);
3675     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3676     if (UNLIKELY(!castedThis)) {
3677         return throwSetterTypeError(*state, "TestObj", "nullableLongSettableAttribute");
3678     }
3679     auto& impl = castedThis->wrapped();
3680     auto nativeValue = toInt32(state, value, NormalConversion);
3681     if (UNLIKELY(state->hadException()))
3682         return false;
3683     impl.setNullableLongSettableAttribute(WTFMove(nativeValue));
3684     return true;
3685 }
3686
3687
3688 bool setJSTestObjNullableStringSettableAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3689 {
3690     JSValue value = JSValue::decode(encodedValue);
3691     UNUSED_PARAM(thisValue);
3692     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3693     if (UNLIKELY(!castedThis)) {
3694         return throwSetterTypeError(*state, "TestObj", "nullableStringSettableAttribute");
3695     }
3696     auto& impl = castedThis->wrapped();
3697     auto nativeValue = valueToStringWithUndefinedOrNullCheck(state, value);
3698     if (UNLIKELY(state->hadException()))
3699         return false;
3700     impl.setNullableStringSettableAttribute(WTFMove(nativeValue));
3701     return true;
3702 }
3703
3704
3705 bool setJSTestObjNullableStringValue(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3706 {
3707     JSValue value = JSValue::decode(encodedValue);
3708     UNUSED_PARAM(thisValue);
3709     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3710     if (UNLIKELY(!castedThis)) {
3711         return throwSetterTypeError(*state, "TestObj", "nullableStringValue");
3712     }
3713     auto& impl = castedThis->wrapped();
3714     auto nativeValue = toInt32(state, value, NormalConversion);
3715     if (UNLIKELY(state->hadException()))
3716         return false;
3717     impl.setNullableStringValue(WTFMove(nativeValue));
3718     return true;
3719 }
3720
3721
3722 bool setJSTestObjAttributeWithReservedEnumType(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3723 {
3724     JSValue value = JSValue::decode(encodedValue);
3725 &n