Some event handler fixes
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestInterface.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
23 #if ENABLE(Condition1) || ENABLE(Condition2)
24
25 #include "JSTestInterface.h"
26
27 #include "ExceptionCode.h"
28 #include "JSDOMBinding.h"
29 #include "ScriptExecutionContext.h"
30 #include "TestInterface.h"
31 #include "TestObj.h"
32 #include "TestSupplemental.h"
33 #include <runtime/Error.h>
34 #include <wtf/GetPtr.h>
35
36 #if ENABLE(Condition11) || ENABLE(Condition12) || ENABLE(Condition22) || ENABLE(Condition23)
37 #include "JSNode.h"
38 #include "JSTestObj.h"
39 #include "Node.h"
40 #include "URL.h"
41 #include <runtime/JSString.h>
42 #endif
43
44 using namespace JSC;
45
46 namespace WebCore {
47
48 // Functions
49
50 #if ENABLE(Condition22) || ENABLE(Condition23)
51 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(JSC::ExecState*);
52 #endif
53 #if ENABLE(Condition22) || ENABLE(Condition23)
54 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(JSC::ExecState*);
55 #endif
56 #if ENABLE(Condition22) || ENABLE(Condition23)
57 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(JSC::ExecState*);
58 #endif
59 #if ENABLE(Condition22) || ENABLE(Condition23)
60 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(JSC::ExecState*);
61 #endif
62 #if ENABLE(Condition11) || ENABLE(Condition12)
63 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(JSC::ExecState*);
64 #endif
65 #if ENABLE(Condition11) || ENABLE(Condition12)
66 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(JSC::ExecState*);
67 #endif
68 #if ENABLE(Condition11) || ENABLE(Condition12)
69 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(JSC::ExecState*);
70 #endif
71 #if ENABLE(Condition11) || ENABLE(Condition12)
72 JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(JSC::ExecState*);
73 #endif
74
75 // Attributes
76
77 #if ENABLE(Condition22) || ENABLE(Condition23)
78 JSC::EncodedJSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
79 #endif
80 #if ENABLE(Condition22) || ENABLE(Condition23)
81 JSC::EncodedJSValue jsTestInterfaceConstructorImplementsStaticAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
82 void setJSTestInterfaceConstructorImplementsStaticAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
83 #endif
84 #if ENABLE(Condition22) || ENABLE(Condition23)
85 JSC::EncodedJSValue jsTestInterfaceImplementsStr1(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
86 #endif
87 #if ENABLE(Condition22) || ENABLE(Condition23)
88 JSC::EncodedJSValue jsTestInterfaceImplementsStr2(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
89 void setJSTestInterfaceImplementsStr2(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
90 #endif
91 #if ENABLE(Condition22) || ENABLE(Condition23)
92 JSC::EncodedJSValue jsTestInterfaceImplementsStr3(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
93 void setJSTestInterfaceImplementsStr3(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
94 #endif
95 #if ENABLE(Condition22) || ENABLE(Condition23)
96 JSC::EncodedJSValue jsTestInterfaceImplementsNode(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
97 void setJSTestInterfaceImplementsNode(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
98 #endif
99 #if ENABLE(Condition11) || ENABLE(Condition12)
100 JSC::EncodedJSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
101 #endif
102 #if ENABLE(Condition11) || ENABLE(Condition12)
103 JSC::EncodedJSValue jsTestInterfaceConstructorSupplementalStaticAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
104 void setJSTestInterfaceConstructorSupplementalStaticAttr(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
105 #endif
106 #if ENABLE(Condition11) || ENABLE(Condition12)
107 JSC::EncodedJSValue jsTestInterfaceSupplementalStr1(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
108 #endif
109 #if ENABLE(Condition11) || ENABLE(Condition12)
110 JSC::EncodedJSValue jsTestInterfaceSupplementalStr2(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
111 void setJSTestInterfaceSupplementalStr2(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
112 #endif
113 #if ENABLE(Condition11) || ENABLE(Condition12)
114 JSC::EncodedJSValue jsTestInterfaceSupplementalStr3(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
115 void setJSTestInterfaceSupplementalStr3(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
116 #endif
117 #if ENABLE(Condition11) || ENABLE(Condition12)
118 JSC::EncodedJSValue jsTestInterfaceSupplementalNode(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
119 void setJSTestInterfaceSupplementalNode(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::EncodedJSValue);
120 #endif
121 JSC::EncodedJSValue jsTestInterfaceConstructor(JSC::ExecState*, JSC::JSObject*, JSC::EncodedJSValue, JSC::PropertyName);
122
123 class JSTestInterfacePrototype : public JSC::JSNonFinalObject {
124 public:
125     typedef JSC::JSNonFinalObject Base;
126     static JSTestInterfacePrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
127     {
128         JSTestInterfacePrototype* ptr = new (NotNull, JSC::allocateCell<JSTestInterfacePrototype>(vm.heap)) JSTestInterfacePrototype(vm, globalObject, structure);
129         ptr->finishCreation(vm);
130         return ptr;
131     }
132
133     DECLARE_INFO;
134     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
135     {
136         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
137     }
138
139 private:
140     JSTestInterfacePrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
141         : JSC::JSNonFinalObject(vm, structure)
142     {
143     }
144
145     void finishCreation(JSC::VM&);
146 };
147
148 class JSTestInterfaceConstructor : public DOMConstructorObject {
149 private:
150     JSTestInterfaceConstructor(JSC::Structure*, JSDOMGlobalObject*);
151     void finishCreation(JSC::VM&, JSDOMGlobalObject*);
152
153 public:
154     typedef DOMConstructorObject Base;
155     static JSTestInterfaceConstructor* create(JSC::VM& vm, JSC::Structure* structure, JSDOMGlobalObject* globalObject)
156     {
157         JSTestInterfaceConstructor* ptr = new (NotNull, JSC::allocateCell<JSTestInterfaceConstructor>(vm.heap)) JSTestInterfaceConstructor(structure, globalObject);
158         ptr->finishCreation(vm, globalObject);
159         return ptr;
160     }
161
162     DECLARE_INFO;
163     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
164     {
165         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
166     }
167 protected:
168     static JSC::EncodedJSValue JSC_HOST_CALL constructJSTestInterface(JSC::ExecState*);
169 #if ENABLE(TEST_INTERFACE)
170     static JSC::ConstructType getConstructData(JSC::JSCell*, JSC::ConstructData&);
171 #endif // ENABLE(TEST_INTERFACE)
172 };
173
174 /* Hash table */
175
176 static const struct CompactHashIndex JSTestInterfaceTableIndex[4] = {
177     { -1, -1 },
178     { 0, -1 },
179     { -1, -1 },
180     { 1, -1 },
181 };
182
183
184 static const HashTableValue JSTestInterfaceTableValues[] =
185 {
186 #if ENABLE(Condition22) || ENABLE(Condition23)
187     { "implementsStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr3) },
188 #else
189     { 0, 0, NoIntrinsic, 0, 0 },
190 #endif
191 #if ENABLE(Condition11) || ENABLE(Condition12)
192     { "supplementalStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr3) },
193 #else
194     { 0, 0, NoIntrinsic, 0, 0 },
195 #endif
196 };
197
198 static const HashTable JSTestInterfaceTable = { 2, 3, true, JSTestInterfaceTableValues, 0, JSTestInterfaceTableIndex };
199 /* Hash table for constructor */
200
201 static const HashTableValue JSTestInterfaceConstructorTableValues[] =
202 {
203 #if ENABLE(Condition22) || ENABLE(Condition23)
204     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(1), (intptr_t) (0) },
205 #else
206     { 0, 0, NoIntrinsic, 0, 0 },
207 #endif
208 #if ENABLE(Condition22) || ENABLE(Condition23)
209     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(2), (intptr_t) (0) },
210 #else
211     { 0, 0, NoIntrinsic, 0, 0 },
212 #endif
213 #if ENABLE(Condition11) || ENABLE(Condition12)
214     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(1), (intptr_t) (0) },
215 #else
216     { 0, 0, NoIntrinsic, 0, 0 },
217 #endif
218 #if ENABLE(Condition11) || ENABLE(Condition12)
219     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(2), (intptr_t) (0) },
220 #else
221     { 0, 0, NoIntrinsic, 0, 0 },
222 #endif
223 #if ENABLE(Condition22) || ENABLE(Condition23)
224     { "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
225 #else
226     { 0, 0, NoIntrinsic, 0, 0 },
227 #endif
228 #if ENABLE(Condition22) || ENABLE(Condition23)
229     { "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorImplementsStaticAttr) },
230 #else
231     { 0, 0, NoIntrinsic, 0, 0 },
232 #endif
233 #if ENABLE(Condition11) || ENABLE(Condition12)
234     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
235 #else
236     { 0, 0, NoIntrinsic, 0, 0 },
237 #endif
238 #if ENABLE(Condition11) || ENABLE(Condition12)
239     { "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorSupplementalStaticAttr) },
240 #else
241     { 0, 0, NoIntrinsic, 0, 0 },
242 #endif
243 #if ENABLE(Condition22) || ENABLE(Condition23)
244     { "implementsMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionImplementsMethod4), (intptr_t) (0) },
245 #else
246     { 0, 0, NoIntrinsic, 0, 0 },
247 #endif
248 #if ENABLE(Condition11) || ENABLE(Condition12)
249     { "supplementalMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t) (0) },
250 #else
251     { 0, 0, NoIntrinsic, 0, 0 },
252 #endif
253 };
254
255
256 #if ENABLE(Condition22) || ENABLE(Condition23)
257 COMPILE_ASSERT(1 == TestInterface::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
258 #endif
259 #if ENABLE(Condition22) || ENABLE(Condition23)
260 COMPILE_ASSERT(2 == TestInterface::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
261 #endif
262 #if ENABLE(Condition11) || ENABLE(Condition12)
263 COMPILE_ASSERT(1 == TestSupplemental::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants);
264 #endif
265 #if ENABLE(Condition11) || ENABLE(Condition12)
266 COMPILE_ASSERT(2 == TestSupplemental::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
267 #endif
268
269 EncodedJSValue JSC_HOST_CALL JSTestInterfaceConstructor::constructJSTestInterface(ExecState* exec)
270 {
271     auto* castedThis = jsCast<JSTestInterfaceConstructor*>(exec->callee());
272     if (UNLIKELY(exec->argumentCount() < 1))
273         return throwVMError(exec, createNotEnoughArgumentsError(exec));
274     ExceptionCode ec = 0;
275     const String& str1(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
276     if (UNLIKELY(exec->hadException()))
277         return JSValue::encode(jsUndefined());
278     const String& str2(exec->argument(1).isEmpty() ? String() : exec->argument(1).toString(exec)->value(exec));
279     if (UNLIKELY(exec->hadException()))
280         return JSValue::encode(jsUndefined());
281     ScriptExecutionContext* context = castedThis->scriptExecutionContext();
282     if (!context)
283         return throwConstructorDocumentUnavailableError(*exec, "TestInterface");
284     RefPtr<TestInterface> object = TestInterface::create(*context, str1, str2, ec);
285     if (ec) {
286         setDOMException(exec, ec);
287         return JSValue::encode(JSValue());
288     }
289     return JSValue::encode(asObject(toJS(exec, castedThis->globalObject(), object.get())));
290 }
291
292 const ClassInfo JSTestInterfaceConstructor::s_info = { "TestInterfaceConstructor", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestInterfaceConstructor) };
293
294 JSTestInterfaceConstructor::JSTestInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
295     : DOMConstructorObject(structure, globalObject)
296 {
297 }
298
299 void JSTestInterfaceConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
300 {
301     Base::finishCreation(vm);
302     ASSERT(inherits(info()));
303     putDirect(vm, vm.propertyNames->prototype, JSTestInterface::getPrototype(vm, globalObject), DontDelete | ReadOnly);
304     putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontDelete | DontEnum);
305     reifyStaticProperties(vm, JSTestInterfaceConstructorTableValues, *this);
306 }
307
308 #if ENABLE(TEST_INTERFACE)
309 ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructData& constructData)
310 {
311     constructData.native.function = constructJSTestInterface;
312     return ConstructTypeHost;
313 }
314 #endif // ENABLE(TEST_INTERFACE)
315
316 /* Hash table for prototype */
317
318 static const HashTableValue JSTestInterfacePrototypeTableValues[] =
319 {
320     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
321 #if ENABLE(Condition22) || ENABLE(Condition23)
322     { "implementsStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
323 #else
324     { 0, 0, NoIntrinsic, 0, 0 },
325 #endif
326 #if ENABLE(Condition22) || ENABLE(Condition23)
327     { "implementsStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr2) },
328 #else
329     { 0, 0, NoIntrinsic, 0, 0 },
330 #endif
331 #if ENABLE(Condition22) || ENABLE(Condition23)
332     { "implementsNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsNode) },
333 #else
334     { 0, 0, NoIntrinsic, 0, 0 },
335 #endif
336 #if ENABLE(Condition11) || ENABLE(Condition12)
337     { "supplementalStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
338 #else
339     { 0, 0, NoIntrinsic, 0, 0 },
340 #endif
341 #if ENABLE(Condition11) || ENABLE(Condition12)
342     { "supplementalStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr2) },
343 #else
344     { 0, 0, NoIntrinsic, 0, 0 },
345 #endif
346 #if ENABLE(Condition11) || ENABLE(Condition12)
347     { "supplementalNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalNode) },
348 #else
349     { 0, 0, NoIntrinsic, 0, 0 },
350 #endif
351 #if ENABLE(Condition22) || ENABLE(Condition23)
352     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(1), (intptr_t) (0) },
353 #else
354     { 0, 0, NoIntrinsic, 0, 0 },
355 #endif
356 #if ENABLE(Condition22) || ENABLE(Condition23)
357     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(2), (intptr_t) (0) },
358 #else
359     { 0, 0, NoIntrinsic, 0, 0 },
360 #endif
361 #if ENABLE(Condition11) || ENABLE(Condition12)
362     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(1), (intptr_t) (0) },
363 #else
364     { 0, 0, NoIntrinsic, 0, 0 },
365 #endif
366 #if ENABLE(Condition11) || ENABLE(Condition12)
367     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, (intptr_t)(2), (intptr_t) (0) },
368 #else
369     { 0, 0, NoIntrinsic, 0, 0 },
370 #endif
371 #if ENABLE(Condition22) || ENABLE(Condition23)
372     { "implementsMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod1), (intptr_t) (0) },
373 #else
374     { 0, 0, NoIntrinsic, 0, 0 },
375 #endif
376 #if ENABLE(Condition22) || ENABLE(Condition23)
377     { "implementsMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod2), (intptr_t) (2) },
378 #else
379     { 0, 0, NoIntrinsic, 0, 0 },
380 #endif
381 #if ENABLE(Condition22) || ENABLE(Condition23)
382     { "implementsMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod3), (intptr_t) (0) },
383 #else
384     { 0, 0, NoIntrinsic, 0, 0 },
385 #endif
386 #if ENABLE(Condition11) || ENABLE(Condition12)
387     { "supplementalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t) (0) },
388 #else
389     { 0, 0, NoIntrinsic, 0, 0 },
390 #endif
391 #if ENABLE(Condition11) || ENABLE(Condition12)
392     { "supplementalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t) (2) },
393 #else
394     { 0, 0, NoIntrinsic, 0, 0 },
395 #endif
396 #if ENABLE(Condition11) || ENABLE(Condition12)
397     { "supplementalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t) (0) },
398 #else
399     { 0, 0, NoIntrinsic, 0, 0 },
400 #endif
401 };
402
403 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
404
405 void JSTestInterfacePrototype::finishCreation(VM& vm)
406 {
407     Base::finishCreation(vm);
408     reifyStaticProperties(vm, JSTestInterfacePrototypeTableValues, *this);
409 }
410
411 const ClassInfo JSTestInterface::s_info = { "TestInterface", &Base::s_info, &JSTestInterfaceTable, CREATE_METHOD_TABLE(JSTestInterface) };
412
413 JSTestInterface::JSTestInterface(Structure* structure, JSDOMGlobalObject* globalObject, Ref<TestInterface>&& impl)
414     : JSDOMWrapper(structure, globalObject)
415     , m_impl(&impl.leakRef())
416 {
417 }
418
419 JSObject* JSTestInterface::createPrototype(VM& vm, JSGlobalObject* globalObject)
420 {
421     return JSTestInterfacePrototype::create(vm, globalObject, JSTestInterfacePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
422 }
423
424 JSObject* JSTestInterface::getPrototype(VM& vm, JSGlobalObject* globalObject)
425 {
426     return getDOMPrototype<JSTestInterface>(vm, globalObject);
427 }
428
429 void JSTestInterface::destroy(JSC::JSCell* cell)
430 {
431     JSTestInterface* thisObject = static_cast<JSTestInterface*>(cell);
432     thisObject->JSTestInterface::~JSTestInterface();
433 }
434
435 JSTestInterface::~JSTestInterface()
436 {
437     releaseImplIfNotNull();
438 }
439
440 bool JSTestInterface::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
441 {
442     auto* thisObject = jsCast<JSTestInterface*>(object);
443     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
444     return getStaticValueSlot<JSTestInterface, Base>(exec, JSTestInterfaceTable, thisObject, propertyName, slot);
445 }
446
447 #if ENABLE(Condition22) || ENABLE(Condition23)
448 EncodedJSValue jsTestInterfaceConstructorImplementsStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
449 {
450     UNUSED_PARAM(exec);
451     UNUSED_PARAM(slotBase);
452     UNUSED_PARAM(thisValue);
453     JSValue result = jsNumber(TestInterface::implementsStaticReadOnlyAttr());
454     return JSValue::encode(result);
455 }
456
457 #endif
458
459 #if ENABLE(Condition22) || ENABLE(Condition23)
460 EncodedJSValue jsTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
461 {
462     UNUSED_PARAM(exec);
463     UNUSED_PARAM(slotBase);
464     UNUSED_PARAM(thisValue);
465     JSValue result = jsStringWithCache(exec, TestInterface::implementsStaticAttr());
466     return JSValue::encode(result);
467 }
468
469 #endif
470
471 #if ENABLE(Condition22) || ENABLE(Condition23)
472 EncodedJSValue jsTestInterfaceImplementsStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
473 {
474     UNUSED_PARAM(exec);
475     UNUSED_PARAM(slotBase);
476     UNUSED_PARAM(thisValue);
477     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
478     if (UNLIKELY(!castedThis)) {
479         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
480             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsStr1");
481         return throwGetterTypeError(*exec, "TestInterface", "implementsStr1");
482     }
483     auto& impl = castedThis->impl();
484     JSValue result = jsStringWithCache(exec, impl.implementsStr1());
485     return JSValue::encode(result);
486 }
487
488 #endif
489
490 #if ENABLE(Condition22) || ENABLE(Condition23)
491 EncodedJSValue jsTestInterfaceImplementsStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
492 {
493     UNUSED_PARAM(exec);
494     UNUSED_PARAM(slotBase);
495     UNUSED_PARAM(thisValue);
496     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
497     if (UNLIKELY(!castedThis)) {
498         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
499             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsStr2");
500         return throwGetterTypeError(*exec, "TestInterface", "implementsStr2");
501     }
502     auto& impl = castedThis->impl();
503     JSValue result = jsStringWithCache(exec, impl.implementsStr2());
504     return JSValue::encode(result);
505 }
506
507 #endif
508
509 #if ENABLE(Condition22) || ENABLE(Condition23)
510 EncodedJSValue jsTestInterfaceImplementsStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
511 {
512     UNUSED_PARAM(exec);
513     UNUSED_PARAM(slotBase);
514     UNUSED_PARAM(thisValue);
515     auto* castedThis = jsCast<JSTestInterface*>(slotBase);
516     return JSValue::encode(castedThis->implementsStr3(exec));
517 }
518
519 #endif
520
521 #if ENABLE(Condition22) || ENABLE(Condition23)
522 EncodedJSValue jsTestInterfaceImplementsNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
523 {
524     UNUSED_PARAM(exec);
525     UNUSED_PARAM(slotBase);
526     UNUSED_PARAM(thisValue);
527     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
528     if (UNLIKELY(!castedThis)) {
529         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
530             return reportDeprecatedGetterError(*exec, "TestInterface", "implementsNode");
531         return throwGetterTypeError(*exec, "TestInterface", "implementsNode");
532     }
533     auto& impl = castedThis->impl();
534     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsNode()));
535     return JSValue::encode(result);
536 }
537
538 #endif
539
540 #if ENABLE(Condition11) || ENABLE(Condition12)
541 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
542 {
543     UNUSED_PARAM(exec);
544     UNUSED_PARAM(slotBase);
545     UNUSED_PARAM(thisValue);
546     JSValue result = jsNumber(TestSupplemental::supplementalStaticReadOnlyAttr());
547     return JSValue::encode(result);
548 }
549
550 #endif
551
552 #if ENABLE(Condition11) || ENABLE(Condition12)
553 EncodedJSValue jsTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
554 {
555     UNUSED_PARAM(exec);
556     UNUSED_PARAM(slotBase);
557     UNUSED_PARAM(thisValue);
558     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStaticAttr());
559     return JSValue::encode(result);
560 }
561
562 #endif
563
564 #if ENABLE(Condition11) || ENABLE(Condition12)
565 EncodedJSValue jsTestInterfaceSupplementalStr1(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
566 {
567     UNUSED_PARAM(exec);
568     UNUSED_PARAM(slotBase);
569     UNUSED_PARAM(thisValue);
570     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
571     if (UNLIKELY(!castedThis)) {
572         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
573             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalStr1");
574         return throwGetterTypeError(*exec, "TestInterface", "supplementalStr1");
575     }
576     auto& impl = castedThis->impl();
577     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr1(&impl));
578     return JSValue::encode(result);
579 }
580
581 #endif
582
583 #if ENABLE(Condition11) || ENABLE(Condition12)
584 EncodedJSValue jsTestInterfaceSupplementalStr2(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
585 {
586     UNUSED_PARAM(exec);
587     UNUSED_PARAM(slotBase);
588     UNUSED_PARAM(thisValue);
589     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
590     if (UNLIKELY(!castedThis)) {
591         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
592             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalStr2");
593         return throwGetterTypeError(*exec, "TestInterface", "supplementalStr2");
594     }
595     auto& impl = castedThis->impl();
596     JSValue result = jsStringWithCache(exec, TestSupplemental::supplementalStr2(&impl));
597     return JSValue::encode(result);
598 }
599
600 #endif
601
602 #if ENABLE(Condition11) || ENABLE(Condition12)
603 EncodedJSValue jsTestInterfaceSupplementalStr3(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
604 {
605     UNUSED_PARAM(exec);
606     UNUSED_PARAM(slotBase);
607     UNUSED_PARAM(thisValue);
608     auto* castedThis = jsCast<JSTestInterface*>(slotBase);
609     return JSValue::encode(castedThis->supplementalStr3(exec));
610 }
611
612 #endif
613
614 #if ENABLE(Condition11) || ENABLE(Condition12)
615 EncodedJSValue jsTestInterfaceSupplementalNode(ExecState* exec, JSObject* slotBase, EncodedJSValue thisValue, PropertyName)
616 {
617     UNUSED_PARAM(exec);
618     UNUSED_PARAM(slotBase);
619     UNUSED_PARAM(thisValue);
620     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
621     if (UNLIKELY(!castedThis)) {
622         if (jsDynamicCast<JSTestInterfacePrototype*>(slotBase))
623             return reportDeprecatedGetterError(*exec, "TestInterface", "supplementalNode");
624         return throwGetterTypeError(*exec, "TestInterface", "supplementalNode");
625     }
626     auto& impl = castedThis->impl();
627     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalNode(&impl)));
628     return JSValue::encode(result);
629 }
630
631 #endif
632
633 EncodedJSValue jsTestInterfaceConstructor(ExecState* exec, JSObject* baseValue, EncodedJSValue, PropertyName)
634 {
635     JSTestInterfacePrototype* domObject = jsDynamicCast<JSTestInterfacePrototype*>(baseValue);
636     if (!domObject)
637         return throwVMTypeError(exec);
638     return JSValue::encode(JSTestInterface::getConstructor(exec->vm(), domObject->globalObject()));
639 }
640
641 void JSTestInterface::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
642 {
643     auto* thisObject = jsCast<JSTestInterface*>(cell);
644     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
645     if (thisObject->putDelegate(exec, propertyName, value, slot))
646         return;
647     Base::put(thisObject, exec, propertyName, value, slot);
648 }
649
650 void JSTestInterface::putByIndex(JSCell* cell, ExecState* exec, unsigned index, JSValue value, bool shouldThrow)
651 {
652     auto* thisObject = jsCast<JSTestInterface*>(cell);
653     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
654     PropertyName propertyName = Identifier::from(exec, index);
655     PutPropertySlot slot(thisObject, shouldThrow);
656     if (thisObject->putDelegate(exec, propertyName, value, slot))
657         return;
658     Base::putByIndex(cell, exec, index, value, shouldThrow);
659 }
660
661 #if ENABLE(Condition22) || ENABLE(Condition23)
662 void setJSTestInterfaceConstructorImplementsStaticAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue, EncodedJSValue encodedValue)
663 {
664     JSValue value = JSValue::decode(encodedValue);
665     UNUSED_PARAM(baseObject);
666     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
667     if (UNLIKELY(exec->hadException()))
668         return;
669     TestInterface::setImplementsStaticAttr(nativeValue);
670 }
671
672 #endif
673
674 #if ENABLE(Condition22) || ENABLE(Condition23)
675 void setJSTestInterfaceImplementsStr2(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
676 {
677     JSValue value = JSValue::decode(encodedValue);
678     UNUSED_PARAM(baseObject);
679     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
680     if (UNLIKELY(!castedThis)) {
681         if (jsDynamicCast<JSTestInterfacePrototype*>(JSValue::decode(thisValue)))
682             reportDeprecatedSetterError(*exec, "TestInterface", "implementsStr2");
683         else
684             throwSetterTypeError(*exec, "TestInterface", "implementsStr2");
685         return;
686     }
687     auto& impl = castedThis->impl();
688     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
689     if (UNLIKELY(exec->hadException()))
690         return;
691     impl.setImplementsStr2(nativeValue);
692 }
693
694 #endif
695
696 #if ENABLE(Condition22) || ENABLE(Condition23)
697 void setJSTestInterfaceImplementsStr3(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
698 {
699     JSValue value = JSValue::decode(encodedValue);
700     UNUSED_PARAM(baseObject);
701     UNUSED_PARAM(thisValue);
702     auto* castedThis = jsCast<JSTestInterface*>(baseObject);
703     UNUSED_PARAM(thisValue);
704     UNUSED_PARAM(exec);
705     castedThis->setImplementsStr3(exec, value);
706 }
707
708 #endif
709
710 #if ENABLE(Condition22) || ENABLE(Condition23)
711 void setJSTestInterfaceImplementsNode(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
712 {
713     JSValue value = JSValue::decode(encodedValue);
714     UNUSED_PARAM(baseObject);
715     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
716     if (UNLIKELY(!castedThis)) {
717         if (jsDynamicCast<JSTestInterfacePrototype*>(JSValue::decode(thisValue)))
718             reportDeprecatedSetterError(*exec, "TestInterface", "implementsNode");
719         else
720             throwSetterTypeError(*exec, "TestInterface", "implementsNode");
721         return;
722     }
723     auto& impl = castedThis->impl();
724     Node* nativeValue(JSNode::toWrapped(value));
725     if (UNLIKELY(exec->hadException()))
726         return;
727     impl.setImplementsNode(nativeValue);
728 }
729
730 #endif
731
732 #if ENABLE(Condition11) || ENABLE(Condition12)
733 void setJSTestInterfaceConstructorSupplementalStaticAttr(ExecState* exec, JSObject* baseObject, EncodedJSValue, EncodedJSValue encodedValue)
734 {
735     JSValue value = JSValue::decode(encodedValue);
736     UNUSED_PARAM(baseObject);
737     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
738     if (UNLIKELY(exec->hadException()))
739         return;
740     TestSupplemental::setSupplementalStaticAttr(nativeValue);
741 }
742
743 #endif
744
745 #if ENABLE(Condition11) || ENABLE(Condition12)
746 void setJSTestInterfaceSupplementalStr2(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
747 {
748     JSValue value = JSValue::decode(encodedValue);
749     UNUSED_PARAM(baseObject);
750     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
751     if (UNLIKELY(!castedThis)) {
752         if (jsDynamicCast<JSTestInterfacePrototype*>(JSValue::decode(thisValue)))
753             reportDeprecatedSetterError(*exec, "TestInterface", "supplementalStr2");
754         else
755             throwSetterTypeError(*exec, "TestInterface", "supplementalStr2");
756         return;
757     }
758     auto& impl = castedThis->impl();
759     const String& nativeValue(value.isEmpty() ? String() : value.toString(exec)->value(exec));
760     if (UNLIKELY(exec->hadException()))
761         return;
762     TestSupplemental::setSupplementalStr2(&impl, nativeValue);
763 }
764
765 #endif
766
767 #if ENABLE(Condition11) || ENABLE(Condition12)
768 void setJSTestInterfaceSupplementalStr3(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
769 {
770     JSValue value = JSValue::decode(encodedValue);
771     UNUSED_PARAM(baseObject);
772     UNUSED_PARAM(thisValue);
773     auto* castedThis = jsCast<JSTestInterface*>(baseObject);
774     UNUSED_PARAM(thisValue);
775     UNUSED_PARAM(exec);
776     castedThis->setSupplementalStr3(exec, value);
777 }
778
779 #endif
780
781 #if ENABLE(Condition11) || ENABLE(Condition12)
782 void setJSTestInterfaceSupplementalNode(ExecState* exec, JSObject* baseObject, EncodedJSValue thisValue, EncodedJSValue encodedValue)
783 {
784     JSValue value = JSValue::decode(encodedValue);
785     UNUSED_PARAM(baseObject);
786     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(JSValue::decode(thisValue));
787     if (UNLIKELY(!castedThis)) {
788         if (jsDynamicCast<JSTestInterfacePrototype*>(JSValue::decode(thisValue)))
789             reportDeprecatedSetterError(*exec, "TestInterface", "supplementalNode");
790         else
791             throwSetterTypeError(*exec, "TestInterface", "supplementalNode");
792         return;
793     }
794     auto& impl = castedThis->impl();
795     Node* nativeValue(JSNode::toWrapped(value));
796     if (UNLIKELY(exec->hadException()))
797         return;
798     TestSupplemental::setSupplementalNode(&impl, nativeValue);
799 }
800
801 #endif
802
803 JSValue JSTestInterface::getConstructor(VM& vm, JSGlobalObject* globalObject)
804 {
805     return getDOMConstructor<JSTestInterfaceConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
806 }
807
808 #if ENABLE(Condition22) || ENABLE(Condition23)
809 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod1(ExecState* exec)
810 {
811     JSValue thisValue = exec->thisValue();
812     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
813     if (UNLIKELY(!castedThis))
814         return throwThisTypeError(*exec, "TestInterface", "implementsMethod1");
815     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
816     auto& impl = castedThis->impl();
817     impl.implementsMethod1();
818     return JSValue::encode(jsUndefined());
819 }
820
821 #endif
822
823 #if ENABLE(Condition22) || ENABLE(Condition23)
824 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(ExecState* exec)
825 {
826     JSValue thisValue = exec->thisValue();
827     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
828     if (UNLIKELY(!castedThis))
829         return throwThisTypeError(*exec, "TestInterface", "implementsMethod2");
830     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
831     auto& impl = castedThis->impl();
832     if (UNLIKELY(exec->argumentCount() < 2))
833         return throwVMError(exec, createNotEnoughArgumentsError(exec));
834     ExceptionCode ec = 0;
835     auto* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
836     if (!scriptContext)
837         return JSValue::encode(jsUndefined());
838     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
839     if (UNLIKELY(exec->hadException()))
840         return JSValue::encode(jsUndefined());
841     TestObj* objArg(JSTestObj::toWrapped(exec->argument(1)));
842     if (UNLIKELY(exec->hadException()))
843         return JSValue::encode(jsUndefined());
844     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
845
846     setDOMException(exec, ec);
847     return JSValue::encode(result);
848 }
849
850 #endif
851
852 #if ENABLE(Condition22) || ENABLE(Condition23)
853 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod3(ExecState* exec)
854 {
855     JSValue thisValue = exec->thisValue();
856     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
857     if (UNLIKELY(!castedThis))
858         return throwThisTypeError(*exec, "TestInterface", "implementsMethod3");
859     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
860     return JSValue::encode(castedThis->implementsMethod3(exec));
861 }
862
863 #endif
864
865 #if ENABLE(Condition22) || ENABLE(Condition23)
866 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionImplementsMethod4(ExecState* exec)
867 {
868     TestInterface::implementsMethod4();
869     return JSValue::encode(jsUndefined());
870 }
871
872 #endif
873
874 #if ENABLE(Condition11) || ENABLE(Condition12)
875 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod1(ExecState* exec)
876 {
877     JSValue thisValue = exec->thisValue();
878     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
879     if (UNLIKELY(!castedThis))
880         return throwThisTypeError(*exec, "TestInterface", "supplementalMethod1");
881     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
882     auto& impl = castedThis->impl();
883     TestSupplemental::supplementalMethod1(&impl);
884     return JSValue::encode(jsUndefined());
885 }
886
887 #endif
888
889 #if ENABLE(Condition11) || ENABLE(Condition12)
890 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2(ExecState* exec)
891 {
892     JSValue thisValue = exec->thisValue();
893     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
894     if (UNLIKELY(!castedThis))
895         return throwThisTypeError(*exec, "TestInterface", "supplementalMethod2");
896     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
897     auto& impl = castedThis->impl();
898     if (UNLIKELY(exec->argumentCount() < 2))
899         return throwVMError(exec, createNotEnoughArgumentsError(exec));
900     ExceptionCode ec = 0;
901     auto* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
902     if (!scriptContext)
903         return JSValue::encode(jsUndefined());
904     const String& strArg(exec->argument(0).isEmpty() ? String() : exec->argument(0).toString(exec)->value(exec));
905     if (UNLIKELY(exec->hadException()))
906         return JSValue::encode(jsUndefined());
907     TestObj* objArg(JSTestObj::toWrapped(exec->argument(1)));
908     if (UNLIKELY(exec->hadException()))
909         return JSValue::encode(jsUndefined());
910     JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
911
912     setDOMException(exec, ec);
913     return JSValue::encode(result);
914 }
915
916 #endif
917
918 #if ENABLE(Condition11) || ENABLE(Condition12)
919 EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod3(ExecState* exec)
920 {
921     JSValue thisValue = exec->thisValue();
922     JSTestInterface* castedThis = jsDynamicCast<JSTestInterface*>(thisValue);
923     if (UNLIKELY(!castedThis))
924         return throwThisTypeError(*exec, "TestInterface", "supplementalMethod3");
925     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestInterface::info());
926     return JSValue::encode(castedThis->supplementalMethod3(exec));
927 }
928
929 #endif
930
931 #if ENABLE(Condition11) || ENABLE(Condition12)
932 EncodedJSValue JSC_HOST_CALL jsTestInterfaceConstructorFunctionSupplementalMethod4(ExecState* exec)
933 {
934     TestSupplemental::supplementalMethod4();
935     return JSValue::encode(jsUndefined());
936 }
937
938 #endif
939
940 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
941 {
942     auto* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
943     if (jsTestInterface->impl().hasPendingActivity())
944         return true;
945     UNUSED_PARAM(visitor);
946     return false;
947 }
948
949 void JSTestInterfaceOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
950 {
951     auto* jsTestInterface = jsCast<JSTestInterface*>(handle.slot()->asCell());
952     auto& world = *static_cast<DOMWrapperWorld*>(context);
953     uncacheWrapper(world, &jsTestInterface->impl(), jsTestInterface);
954     jsTestInterface->releaseImpl();
955 }
956
957 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject* globalObject, TestInterface* impl)
958 {
959     if (!impl)
960         return jsNull();
961     if (JSValue result = getExistingWrapper<JSTestInterface>(globalObject, impl))
962         return result;
963 #if COMPILER(CLANG)
964     // If you hit this failure the interface definition has the ImplementationLacksVTable
965     // attribute. You should remove that attribute. If the class has subclasses
966     // that may be passed through this toJS() function you should use the SkipVTableValidation
967     // attribute to TestInterface.
968     COMPILE_ASSERT(!__is_polymorphic(TestInterface), TestInterface_is_polymorphic_but_idl_claims_not_to_be);
969 #endif
970     return createNewWrapper<JSTestInterface>(globalObject, impl);
971 }
972
973 TestInterface* JSTestInterface::toWrapped(JSC::JSValue value)
974 {
975     if (auto* wrapper = jsDynamicCast<JSTestInterface*>(value))
976         return &wrapper->impl();
977     return nullptr;
978 }
979
980 }
981
982 #endif // ENABLE(Condition1) || ENABLE(Condition2)