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