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