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