Move forward declaration of bindings static functions into their implementation files
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestTypedefs.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 "JSTestTypedefs.h"
23
24 #include "DOMStringList.h"
25 #include "ExceptionCode.h"
26 #include "JSDOMBinding.h"
27 #include "JSDOMStringList.h"
28 #include "JSSVGPoint.h"
29 #include "JSSerializedScriptValue.h"
30 #include "JSTestCallback.h"
31 #include "JSTestEventTarget.h"
32 #include "JSTestSubObj.h"
33 #include "SVGPoint.h"
34 #include "ScriptExecutionContext.h"
35 #include "SerializedScriptValue.h"
36 #include "TestTypedefs.h"
37 #include "URL.h"
38 #include <runtime/Error.h>
39 #include <runtime/JSArray.h>
40 #include <runtime/JSString.h>
41 #include <wtf/GetPtr.h>
42
43 using namespace JSC;
44
45 namespace WebCore {
46
47 // Functions
48
49 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFunc(JSC::ExecState*);
50 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionSetShadow(JSC::ExecState*);
51 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithSequenceArg(JSC::ExecState*);
52 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionNullableArrayArg(JSC::ExecState*);
53 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFuncWithClamp(JSC::ExecState*);
54 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionImmutablePointFunction(JSC::ExecState*);
55 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction(JSC::ExecState*);
56 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction2(JSC::ExecState*);
57 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude(JSC::ExecState*);
58 JSC::EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithException(JSC::ExecState*);
59 // Attributes
60
61 JSC::EncodedJSValue jsTestTypedefsUnsignedLongLongAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
62 void setJSTestTypedefsUnsignedLongLongAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
63 JSC::EncodedJSValue jsTestTypedefsImmutableSerializedScriptValue(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
64 void setJSTestTypedefsImmutableSerializedScriptValue(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
65 JSC::EncodedJSValue jsTestTypedefsConstructorTestSubObj(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
66 JSC::EncodedJSValue jsTestTypedefsAttrWithGetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
67 void setJSTestTypedefsAttrWithGetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
68 JSC::EncodedJSValue jsTestTypedefsAttrWithSetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
69 void setJSTestTypedefsAttrWithSetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
70 JSC::EncodedJSValue jsTestTypedefsStringAttrWithGetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
71 void setJSTestTypedefsStringAttrWithGetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
72 JSC::EncodedJSValue jsTestTypedefsStringAttrWithSetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
73 void setJSTestTypedefsStringAttrWithSetterException(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
74 JSC::EncodedJSValue jsTestTypedefsConstructor(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
75 /* Hash table */
76
77 static const struct CompactHashIndex JSTestTypedefsTableIndex[2] = {
78     { -1, -1 },
79     { -1, -1 },
80 };
81
82
83 static const HashTableValue JSTestTypedefsTableValues[] =
84 {
85     { 0, 0, NoIntrinsic, 0, 0 }
86 };
87
88 static const HashTable JSTestTypedefsTable = { 0, 1, false, JSTestTypedefsTableValues, 0, JSTestTypedefsTableIndex };
89 /* Hash table for constructor */
90
91 static const struct CompactHashIndex JSTestTypedefsConstructorTableIndex[1] = {
92     { 0, -1 },
93 };
94
95
96 static const HashTableValue JSTestTypedefsConstructorTableValues[] =
97 {
98     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
99 };
100
101 static const HashTable JSTestTypedefsConstructorTable = { 1, 0, true, JSTestTypedefsConstructorTableValues, 0, JSTestTypedefsConstructorTableIndex };
102 EncodedJSValue JSC_HOST_CALL JSTestTypedefsConstructor::constructJSTestTypedefs(ExecState* exec)
103 {
104     JSTestTypedefsConstructor* castedThis = jsCast<JSTestTypedefsConstructor*>(exec->callee());
105     if (exec->argumentCount() < 2)
106         return throwVMError(exec, createNotEnoughArgumentsError(exec));
107     const String& hello(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
108     if (UNLIKELY(exec->hadException()))
109         return JSValue::encode(jsUndefined());
110     if (!exec->argument(1).isFunction())
111         return throwArgumentMustBeFunctionError(*exec, 1, "testCallback", "TestTypedefs", nullptr);
112     RefPtr<TestCallback> testCallback = JSTestCallback::create(asObject(exec->uncheckedArgument(1)), castedThis->globalObject());
113     RefPtr<TestTypedefs> object = TestTypedefs::create(hello, testCallback);
114     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
115 }
116
117 const ClassInfo JSTestTypedefsConstructor::s_info = { "TestTypedefsConstructor", &Base::s_info, &JSTestTypedefsConstructorTable, 0, CREATE_METHOD_TABLE(JSTestTypedefsConstructor) };
118
119 JSTestTypedefsConstructor::JSTestTypedefsConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
120     : DOMConstructorObject(structure, globalObject)
121 {
122 }
123
124 void JSTestTypedefsConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
125 {
126     Base::finishCreation(vm);
127     ASSERT(inherits(info()));
128     putDirect(vm, vm.propertyNames->prototype, JSTestTypedefsPrototype::self(vm, globalObject), DontDelete | ReadOnly);
129     putDirect(vm, vm.propertyNames->length, jsNumber(2), ReadOnly | DontDelete | DontEnum);
130     reifyStaticProperties(vm, JSTestTypedefsConstructorTableValues, *this);
131 }
132
133 ConstructType JSTestTypedefsConstructor::getConstructData(JSCell*, ConstructData& constructData)
134 {
135     constructData.native.function = constructJSTestTypedefs;
136     return ConstructTypeHost;
137 }
138
139 /* Hash table for prototype */
140
141 static const struct CompactHashIndex JSTestTypedefsPrototypeTableIndex[66] = {
142     { -1, -1 },
143     { -1, -1 },
144     { -1, -1 },
145     { -1, -1 },
146     { 9, -1 },
147     { -1, -1 },
148     { -1, -1 },
149     { -1, -1 },
150     { -1, -1 },
151     { -1, -1 },
152     { -1, -1 },
153     { -1, -1 },
154     { -1, -1 },
155     { -1, -1 },
156     { -1, -1 },
157     { -1, -1 },
158     { -1, -1 },
159     { -1, -1 },
160     { -1, -1 },
161     { 16, -1 },
162     { -1, -1 },
163     { -1, -1 },
164     { 2, -1 },
165     { -1, -1 },
166     { -1, -1 },
167     { 0, 64 },
168     { -1, -1 },
169     { -1, -1 },
170     { -1, -1 },
171     { -1, -1 },
172     { 11, -1 },
173     { -1, -1 },
174     { -1, -1 },
175     { 5, -1 },
176     { -1, -1 },
177     { 8, -1 },
178     { -1, -1 },
179     { 12, -1 },
180     { -1, -1 },
181     { -1, -1 },
182     { -1, -1 },
183     { -1, -1 },
184     { -1, -1 },
185     { 15, -1 },
186     { -1, -1 },
187     { -1, -1 },
188     { -1, -1 },
189     { -1, -1 },
190     { -1, -1 },
191     { -1, -1 },
192     { -1, -1 },
193     { 14, -1 },
194     { -1, -1 },
195     { 1, -1 },
196     { 3, -1 },
197     { 4, 65 },
198     { -1, -1 },
199     { -1, -1 },
200     { 10, -1 },
201     { -1, -1 },
202     { -1, -1 },
203     { 13, -1 },
204     { -1, -1 },
205     { -1, -1 },
206     { 6, -1 },
207     { 7, -1 },
208 };
209
210
211 static const HashTableValue JSTestTypedefsPrototypeTableValues[] =
212 {
213     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
214     { "unsignedLongLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsUnsignedLongLongAttr) },
215     { "immutableSerializedScriptValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsImmutableSerializedScriptValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsImmutableSerializedScriptValue) },
216     { "attrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsAttrWithGetterException) },
217     { "attrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsAttrWithSetterException) },
218     { "stringAttrWithGetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsStringAttrWithGetterException) },
219     { "stringAttrWithSetterException", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsStringAttrWithSetterException) },
220     { "func", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionFunc), (intptr_t) (0) },
221     { "setShadow", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionSetShadow), (intptr_t) (3) },
222     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) },
223     { "nullableArrayArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionNullableArrayArg), (intptr_t) (1) },
224     { "funcWithClamp", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionFuncWithClamp), (intptr_t) (1) },
225     { "immutablePointFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionImmutablePointFunction), (intptr_t) (0) },
226     { "stringArrayFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionStringArrayFunction), (intptr_t) (1) },
227     { "stringArrayFunction2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionStringArrayFunction2), (intptr_t) (1) },
228     { "callWithSequenceThatRequiresInclude", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude), (intptr_t) (1) },
229     { "methodWithException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionMethodWithException), (intptr_t) (0) },
230 };
231
232 static const HashTable JSTestTypedefsPrototypeTable = { 17, 63, true, JSTestTypedefsPrototypeTableValues, 0, JSTestTypedefsPrototypeTableIndex };
233 const ClassInfo JSTestTypedefsPrototype::s_info = { "TestTypedefsPrototype", &Base::s_info, &JSTestTypedefsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestTypedefsPrototype) };
234
235 JSObject* JSTestTypedefsPrototype::self(VM& vm, JSGlobalObject* globalObject)
236 {
237     return getDOMPrototype<JSTestTypedefs>(vm, globalObject);
238 }
239
240 void JSTestTypedefsPrototype::finishCreation(VM& vm)
241 {
242     Base::finishCreation(vm);
243     reifyStaticProperties(vm, JSTestTypedefsPrototypeTableValues, *this);
244 }
245
246 const ClassInfo JSTestTypedefs::s_info = { "TestTypedefs", &Base::s_info, &JSTestTypedefsTable, 0 , CREATE_METHOD_TABLE(JSTestTypedefs) };
247
248 JSTestTypedefs::JSTestTypedefs(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestTypedefs> impl)
249     : JSDOMWrapper(structure, globalObject)
250     , m_impl(impl.leakRef())
251 {
252 }
253
254 JSObject* JSTestTypedefs::createPrototype(VM& vm, JSGlobalObject* globalObject)
255 {
256     return JSTestTypedefsPrototype::create(vm, globalObject, JSTestTypedefsPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
257 }
258
259 void JSTestTypedefs::destroy(JSC::JSCell* cell)
260 {
261     JSTestTypedefs* thisObject = static_cast<JSTestTypedefs*>(cell);
262     thisObject->JSTestTypedefs::~JSTestTypedefs();
263 }
264
265 JSTestTypedefs::~JSTestTypedefs()
266 {
267     releaseImplIfNotNull();
268 }
269
270 bool JSTestTypedefs::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
271 {
272     JSTestTypedefs* thisObject = jsCast<JSTestTypedefs*>(object);
273     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
274     return getStaticValueSlot<JSTestTypedefs, Base>(exec, JSTestTypedefsTable, thisObject, propertyName, slot);
275 }
276
277 EncodedJSValue jsTestTypedefsUnsignedLongLongAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
278 {
279     UNUSED_PARAM(exec);
280     UNUSED_PARAM(slotBase);
281     UNUSED_PARAM(thisValue);
282     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
283     if (UNLIKELY(!castedThis)) {
284         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
285             return reportDeprecatedGetterError(*exec, "TestTypedefs", "unsignedLongLongAttr");
286         return throwGetterTypeError(*exec, "TestTypedefs", "unsignedLongLongAttr");
287     }
288     TestTypedefs& impl = castedThis->impl();
289     JSValue result = jsNumber(impl.unsignedLongLongAttr());
290     return JSValue::encode(result);
291 }
292
293
294 EncodedJSValue jsTestTypedefsImmutableSerializedScriptValue(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
295 {
296     UNUSED_PARAM(exec);
297     UNUSED_PARAM(slotBase);
298     UNUSED_PARAM(thisValue);
299     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
300     if (UNLIKELY(!castedThis)) {
301         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
302             return reportDeprecatedGetterError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
303         return throwGetterTypeError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
304     }
305     TestTypedefs& impl = castedThis->impl();
306     JSValue result = impl.immutableSerializedScriptValue() ? impl.immutableSerializedScriptValue()->deserialize(exec, castedThis->globalObject(), 0) : jsNull();
307     return JSValue::encode(result);
308 }
309
310
311 EncodedJSValue jsTestTypedefsConstructorTestSubObj(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
312 {
313     UNUSED_PARAM(exec);
314     UNUSED_PARAM(slotBase);
315     UNUSED_PARAM(thisValue);
316     JSTestTypedefs* castedThis = jsCast<JSTestTypedefs*>(slotBase);
317     return JSValue::encode(JSTestSubObj::getConstructor(exec->vm(), castedThis->globalObject()));
318 }
319
320
321 EncodedJSValue jsTestTypedefsAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
322 {
323     UNUSED_PARAM(exec);
324     UNUSED_PARAM(slotBase);
325     UNUSED_PARAM(thisValue);
326     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
327     if (UNLIKELY(!castedThis)) {
328         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
329             return reportDeprecatedGetterError(*exec, "TestTypedefs", "attrWithGetterException");
330         return throwGetterTypeError(*exec, "TestTypedefs", "attrWithGetterException");
331     }
332     ExceptionCode ec = 0;
333     TestTypedefs& impl = castedThis->impl();
334     JSValue result = jsNumber(impl.attrWithGetterException(ec));
335     setDOMException(exec, ec);
336     return JSValue::encode(result);
337 }
338
339
340 EncodedJSValue jsTestTypedefsAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
341 {
342     UNUSED_PARAM(exec);
343     UNUSED_PARAM(slotBase);
344     UNUSED_PARAM(thisValue);
345     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
346     if (UNLIKELY(!castedThis)) {
347         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
348             return reportDeprecatedGetterError(*exec, "TestTypedefs", "attrWithSetterException");
349         return throwGetterTypeError(*exec, "TestTypedefs", "attrWithSetterException");
350     }
351     TestTypedefs& impl = castedThis->impl();
352     JSValue result = jsNumber(impl.attrWithSetterException());
353     return JSValue::encode(result);
354 }
355
356
357 EncodedJSValue jsTestTypedefsStringAttrWithGetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
358 {
359     UNUSED_PARAM(exec);
360     UNUSED_PARAM(slotBase);
361     UNUSED_PARAM(thisValue);
362     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
363     if (UNLIKELY(!castedThis)) {
364         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
365             return reportDeprecatedGetterError(*exec, "TestTypedefs", "stringAttrWithGetterException");
366         return throwGetterTypeError(*exec, "TestTypedefs", "stringAttrWithGetterException");
367     }
368     ExceptionCode ec = 0;
369     TestTypedefs& impl = castedThis->impl();
370     JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
371     setDOMException(exec, ec);
372     return JSValue::encode(result);
373 }
374
375
376 EncodedJSValue jsTestTypedefsStringAttrWithSetterException(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
377 {
378     UNUSED_PARAM(exec);
379     UNUSED_PARAM(slotBase);
380     UNUSED_PARAM(thisValue);
381     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
382     if (UNLIKELY(!castedThis)) {
383         if (jsDynamicCast<JSTestTypedefsPrototype*>(slotBase))
384             return reportDeprecatedGetterError(*exec, "TestTypedefs", "stringAttrWithSetterException");
385         return throwGetterTypeError(*exec, "TestTypedefs", "stringAttrWithSetterException");
386     }
387     TestTypedefs& impl = castedThis->impl();
388     JSValue result = jsStringWithCache(exec, impl.stringAttrWithSetterException());
389     return JSValue::encode(result);
390 }
391
392
393 EncodedJSValue jsTestTypedefsConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue, PropertyName)
394 {
395     JSTestTypedefsPrototype* domObject = jsDynamicCast<JSTestTypedefsPrototype*>(baseValue);
396     if (!domObject)
397         return throwVMTypeError(exec);
398     return JSValue::encode(JSTestTypedefs::getConstructor(exec->vm(), domObject->globalObject()));
399 }
400
401 void setJSTestTypedefsUnsignedLongLongAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
402 {
403     JSValue value = JSValue::decode(encodedValue);
404     UNUSED_PARAM(baseObject);
405     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
406     if (UNLIKELY(!castedThis)) {
407         if (jsDynamicCast<JSTestTypedefsPrototype*>(JSValue::decode(thisValue)))
408             reportDeprecatedSetterError(*exec, "TestTypedefs", "unsignedLongLongAttr");
409         else
410             throwSetterTypeError(*exec, "TestTypedefs", "unsignedLongLongAttr");
411         return;
412     }
413     TestTypedefs& impl = castedThis->impl();
414     unsigned long long nativeValue(toUInt64(exec, value, NormalConversion));
415     if (UNLIKELY(exec->hadException()))
416         return;
417     impl.setUnsignedLongLongAttr(nativeValue);
418 }
419
420
421 void setJSTestTypedefsImmutableSerializedScriptValue(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
422 {
423     JSValue value = JSValue::decode(encodedValue);
424     UNUSED_PARAM(baseObject);
425     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
426     if (UNLIKELY(!castedThis)) {
427         if (jsDynamicCast<JSTestTypedefsPrototype*>(JSValue::decode(thisValue)))
428             reportDeprecatedSetterError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
429         else
430             throwSetterTypeError(*exec, "TestTypedefs", "immutableSerializedScriptValue");
431         return;
432     }
433     TestTypedefs& impl = castedThis->impl();
434     RefPtr<SerializedScriptValue> nativeValue(SerializedScriptValue::create(exec, value, 0, 0));
435     if (UNLIKELY(exec->hadException()))
436         return;
437     impl.setImmutableSerializedScriptValue(nativeValue);
438 }
439
440
441 void setJSTestTypedefsAttrWithGetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
442 {
443     JSValue value = JSValue::decode(encodedValue);
444     UNUSED_PARAM(baseObject);
445     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
446     if (UNLIKELY(!castedThis)) {
447         if (jsDynamicCast<JSTestTypedefsPrototype*>(JSValue::decode(thisValue)))
448             reportDeprecatedSetterError(*exec, "TestTypedefs", "attrWithGetterException");
449         else
450             throwSetterTypeError(*exec, "TestTypedefs", "attrWithGetterException");
451         return;
452     }
453     TestTypedefs& impl = castedThis->impl();
454     int nativeValue(toInt32(exec, value, NormalConversion));
455     if (UNLIKELY(exec->hadException()))
456         return;
457     impl.setAttrWithGetterException(nativeValue);
458 }
459
460
461 void setJSTestTypedefsAttrWithSetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
462 {
463     JSValue value = JSValue::decode(encodedValue);
464     UNUSED_PARAM(baseObject);
465     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
466     if (UNLIKELY(!castedThis)) {
467         if (jsDynamicCast<JSTestTypedefsPrototype*>(JSValue::decode(thisValue)))
468             reportDeprecatedSetterError(*exec, "TestTypedefs", "attrWithSetterException");
469         else
470             throwSetterTypeError(*exec, "TestTypedefs", "attrWithSetterException");
471         return;
472     }
473     TestTypedefs& impl = castedThis->impl();
474     ExceptionCode ec = 0;
475     int nativeValue(toInt32(exec, value, NormalConversion));
476     if (UNLIKELY(exec->hadException()))
477         return;
478     impl.setAttrWithSetterException(nativeValue, ec);
479     setDOMException(exec, ec);
480 }
481
482
483 void setJSTestTypedefsStringAttrWithGetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
484 {
485     JSValue value = JSValue::decode(encodedValue);
486     UNUSED_PARAM(baseObject);
487     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
488     if (UNLIKELY(!castedThis)) {
489         if (jsDynamicCast<JSTestTypedefsPrototype*>(JSValue::decode(thisValue)))
490             reportDeprecatedSetterError(*exec, "TestTypedefs", "stringAttrWithGetterException");
491         else
492             throwSetterTypeError(*exec, "TestTypedefs", "stringAttrWithGetterException");
493         return;
494     }
495     TestTypedefs& impl = castedThis->impl();
496     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
497     if (UNLIKELY(exec->hadException()))
498         return;
499     impl.setStringAttrWithGetterException(nativeValue);
500 }
501
502
503 void setJSTestTypedefsStringAttrWithSetterException(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
504 {
505     JSValue value = JSValue::decode(encodedValue);
506     UNUSED_PARAM(baseObject);
507     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(JSValue::decode(thisValue));
508     if (UNLIKELY(!castedThis)) {
509         if (jsDynamicCast<JSTestTypedefsPrototype*>(JSValue::decode(thisValue)))
510             reportDeprecatedSetterError(*exec, "TestTypedefs", "stringAttrWithSetterException");
511         else
512             throwSetterTypeError(*exec, "TestTypedefs", "stringAttrWithSetterException");
513         return;
514     }
515     TestTypedefs& impl = castedThis->impl();
516     ExceptionCode ec = 0;
517     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
518     if (UNLIKELY(exec->hadException()))
519         return;
520     impl.setStringAttrWithSetterException(nativeValue, ec);
521     setDOMException(exec, ec);
522 }
523
524
525 JSValue JSTestTypedefs::getConstructor(VM& vm, JSGlobalObject* globalObject)
526 {
527     return getDOMConstructor<JSTestTypedefsConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
528 }
529
530 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFunc(ExecState* exec)
531 {
532     JSValue thisValue = exec->thisValue();
533     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
534     if (UNLIKELY(!castedThis))
535         return throwThisTypeError(*exec, "TestTypedefs", "func");
536     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
537     TestTypedefs& impl = castedThis->impl();
538
539     size_t argsCount = exec->argumentCount();
540     if (argsCount <= 0) {
541         impl.func();
542         return JSValue::encode(jsUndefined());
543     }
544
545     Vector<int> x(toNativeArray<int>(exec, exec->argument(0)));
546     if (UNLIKELY(exec->hadException()))
547         return JSValue::encode(jsUndefined());
548     impl.func(x);
549     return JSValue::encode(jsUndefined());
550 }
551
552 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionSetShadow(ExecState* exec)
553 {
554     JSValue thisValue = exec->thisValue();
555     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
556     if (UNLIKELY(!castedThis))
557         return throwThisTypeError(*exec, "TestTypedefs", "setShadow");
558     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
559     TestTypedefs& impl = castedThis->impl();
560     if (exec->argumentCount() < 3)
561         return throwVMError(exec, createNotEnoughArgumentsError(exec));
562     float width(exec->argument(0).toFloat(exec));
563     if (UNLIKELY(exec->hadException()))
564         return JSValue::encode(jsUndefined());
565     float height(exec->argument(1).toFloat(exec));
566     if (UNLIKELY(exec->hadException()))
567         return JSValue::encode(jsUndefined());
568     float blur(exec->argument(2).toFloat(exec));
569     if (UNLIKELY(exec->hadException()))
570         return JSValue::encode(jsUndefined());
571
572     size_t argsCount = exec->argumentCount();
573     if (argsCount <= 3) {
574         impl.setShadow(width, height, blur);
575         return JSValue::encode(jsUndefined());
576     }
577
578     const String& color(exec->argument(3).isEmpty() ? String() : exec->argument(3).toString(exec)->value(exec));
579     if (UNLIKELY(exec->hadException()))
580         return JSValue::encode(jsUndefined());
581     if (argsCount <= 4) {
582         impl.setShadow(width, height, blur, color);
583         return JSValue::encode(jsUndefined());
584     }
585
586     float alpha(exec->argument(4).toFloat(exec));
587     if (UNLIKELY(exec->hadException()))
588         return JSValue::encode(jsUndefined());
589     impl.setShadow(width, height, blur, color, alpha);
590     return JSValue::encode(jsUndefined());
591 }
592
593 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithSequenceArg(ExecState* exec)
594 {
595     JSValue thisValue = exec->thisValue();
596     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
597     if (UNLIKELY(!castedThis))
598         return throwThisTypeError(*exec, "TestTypedefs", "methodWithSequenceArg");
599     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
600     TestTypedefs& impl = castedThis->impl();
601     if (exec->argumentCount() < 1)
602         return throwVMError(exec, createNotEnoughArgumentsError(exec));
603     Vector<RefPtr<SerializedScriptValue>> sequenceArg((toRefPtrNativeArray<SerializedScriptValue, JSSerializedScriptValue>(exec, exec->argument(0), &toSerializedScriptValue)));
604     if (UNLIKELY(exec->hadException()))
605         return JSValue::encode(jsUndefined());
606     JSValue result = jsNumber(impl.methodWithSequenceArg(sequenceArg));
607     return JSValue::encode(result);
608 }
609
610 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionNullableArrayArg(ExecState* exec)
611 {
612     JSValue thisValue = exec->thisValue();
613     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
614     if (UNLIKELY(!castedThis))
615         return throwThisTypeError(*exec, "TestTypedefs", "nullableArrayArg");
616     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
617     TestTypedefs& impl = castedThis->impl();
618     if (exec->argumentCount() < 1)
619         return throwVMError(exec, createNotEnoughArgumentsError(exec));
620     Vector<String> arrayArg(toNativeArray<String>(exec, exec->argument(0)));
621     if (UNLIKELY(exec->hadException()))
622         return JSValue::encode(jsUndefined());
623     impl.nullableArrayArg(arrayArg);
624     return JSValue::encode(jsUndefined());
625 }
626
627 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionFuncWithClamp(ExecState* exec)
628 {
629     JSValue thisValue = exec->thisValue();
630     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
631     if (UNLIKELY(!castedThis))
632         return throwThisTypeError(*exec, "TestTypedefs", "funcWithClamp");
633     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
634     TestTypedefs& impl = castedThis->impl();
635     if (exec->argumentCount() < 1)
636         return throwVMError(exec, createNotEnoughArgumentsError(exec));
637     unsigned long long arg1 = 0;
638     double arg1NativeValue = exec->argument(0).toNumber(exec);
639     if (UNLIKELY(exec->hadException()))
640         return JSValue::encode(jsUndefined());
641
642     if (!std::isnan(arg1NativeValue))
643         arg1 = clampTo<unsigned long long>(arg1NativeValue);
644
645
646     size_t argsCount = exec->argumentCount();
647     if (argsCount <= 1) {
648         impl.funcWithClamp(arg1);
649         return JSValue::encode(jsUndefined());
650     }
651
652     unsigned long long arg2 = 0;
653     double arg2NativeValue = exec->argument(1).toNumber(exec);
654     if (UNLIKELY(exec->hadException()))
655         return JSValue::encode(jsUndefined());
656
657     if (!std::isnan(arg2NativeValue))
658         arg2 = clampTo<unsigned long long>(arg2NativeValue);
659
660     impl.funcWithClamp(arg1, arg2);
661     return JSValue::encode(jsUndefined());
662 }
663
664 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionImmutablePointFunction(ExecState* exec)
665 {
666     JSValue thisValue = exec->thisValue();
667     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
668     if (UNLIKELY(!castedThis))
669         return throwThisTypeError(*exec, "TestTypedefs", "immutablePointFunction");
670     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
671     TestTypedefs& impl = castedThis->impl();
672     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
673     return JSValue::encode(result);
674 }
675
676 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction(ExecState* exec)
677 {
678     JSValue thisValue = exec->thisValue();
679     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
680     if (UNLIKELY(!castedThis))
681         return throwThisTypeError(*exec, "TestTypedefs", "stringArrayFunction");
682     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
683     TestTypedefs& impl = castedThis->impl();
684     if (exec->argumentCount() < 1)
685         return throwVMError(exec, createNotEnoughArgumentsError(exec));
686     ExceptionCode ec = 0;
687     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
688     if (UNLIKELY(exec->hadException()))
689         return JSValue::encode(jsUndefined());
690     JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
691
692     setDOMException(exec, ec);
693     return JSValue::encode(result);
694 }
695
696 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction2(ExecState* exec)
697 {
698     JSValue thisValue = exec->thisValue();
699     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
700     if (UNLIKELY(!castedThis))
701         return throwThisTypeError(*exec, "TestTypedefs", "stringArrayFunction2");
702     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
703     TestTypedefs& impl = castedThis->impl();
704     if (exec->argumentCount() < 1)
705         return throwVMError(exec, createNotEnoughArgumentsError(exec));
706     ExceptionCode ec = 0;
707     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
708     if (UNLIKELY(exec->hadException()))
709         return JSValue::encode(jsUndefined());
710     JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction2(values, ec));
711
712     setDOMException(exec, ec);
713     return JSValue::encode(result);
714 }
715
716 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude(ExecState* exec)
717 {
718     JSValue thisValue = exec->thisValue();
719     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
720     if (UNLIKELY(!castedThis))
721         return throwThisTypeError(*exec, "TestTypedefs", "callWithSequenceThatRequiresInclude");
722     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
723     TestTypedefs& impl = castedThis->impl();
724     if (exec->argumentCount() < 1)
725         return throwVMError(exec, createNotEnoughArgumentsError(exec));
726     Vector<RefPtr<TestEventTarget>> sequenceArg((toRefPtrNativeArray<TestEventTarget, JSTestEventTarget>(exec, exec->argument(0), &toTestEventTarget)));
727     if (UNLIKELY(exec->hadException()))
728         return JSValue::encode(jsUndefined());
729     JSValue result = jsBoolean(impl.callWithSequenceThatRequiresInclude(sequenceArg));
730     return JSValue::encode(result);
731 }
732
733 EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithException(ExecState* exec)
734 {
735     JSValue thisValue = exec->thisValue();
736     JSTestTypedefs* castedThis = jsDynamicCast<JSTestTypedefs*>(thisValue);
737     if (UNLIKELY(!castedThis))
738         return throwThisTypeError(*exec, "TestTypedefs", "methodWithException");
739     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
740     TestTypedefs& impl = castedThis->impl();
741     ExceptionCode ec = 0;
742     impl.methodWithException(ec);
743     setDOMException(exec, ec);
744     return JSValue::encode(jsUndefined());
745 }
746
747 bool JSTestTypedefsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
748 {
749     UNUSED_PARAM(handle);
750     UNUSED_PARAM(visitor);
751     return false;
752 }
753
754 void JSTestTypedefsOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
755 {
756     JSTestTypedefs* jsTestTypedefs = jsCast<JSTestTypedefs*>(handle.slot()->asCell());
757     DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
758     uncacheWrapper(world, &jsTestTypedefs->impl(), jsTestTypedefs);
759     jsTestTypedefs->releaseImpl();
760 }
761
762 #if ENABLE(BINDING_INTEGRITY)
763 #if PLATFORM(WIN)
764 #pragma warning(disable: 4483)
765 extern "C" { extern void (*const __identifier("??_7TestTypedefs@WebCore@@6B@")[])(); }
766 #else
767 extern "C" { extern void* _ZTVN7WebCore12TestTypedefsE[]; }
768 #endif
769 #endif
770 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestTypedefs* impl)
771 {
772     if (!impl)
773         return jsNull();
774     if (JSValue result = getExistingWrapper<JSTestTypedefs>(globalObject, impl))
775         return result;
776
777 #if ENABLE(BINDING_INTEGRITY)
778     void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
779 #if PLATFORM(WIN)
780     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestTypedefs@WebCore@@6B@"));
781 #else
782     void* expectedVTablePointer = &_ZTVN7WebCore12TestTypedefsE[2];
783 #if COMPILER(CLANG)
784     // If this fails TestTypedefs does not have a vtable, so you need to add the
785     // ImplementationLacksVTable attribute to the interface definition
786     COMPILE_ASSERT(__is_polymorphic(TestTypedefs), TestTypedefs_is_not_polymorphic);
787 #endif
788 #endif
789     // If you hit this assertion you either have a use after free bug, or
790     // TestTypedefs has subclasses. If TestTypedefs has subclasses that get passed
791     // to toJS() we currently require TestTypedefs you to opt out of binding hardening
792     // by adding the SkipVTableValidation attribute to the interface IDL definition
793     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
794 #endif
795     return createNewWrapper<JSTestTypedefs>(globalObject, impl);
796 }
797
798 TestTypedefs* toTestTypedefs(JSC::JSValue value)
799 {
800     if (auto* wrapper = jsDynamicCast<JSTestTypedefs*>(value))
801         return &wrapper->impl();
802     return nullptr;
803 }
804
805 }