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