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