Change WebCore sources to work with unified source builds
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestNamedGetterNoIdentifier.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 "JSTestNamedGetterNoIdentifier.h"
23
24 #include "JSDOMAbstractOperations.h"
25 #include "JSDOMBinding.h"
26 #include "JSDOMConstructorNotConstructable.h"
27 #include "JSDOMConvertStrings.h"
28 #include "JSDOMExceptionHandling.h"
29 #include "JSDOMWrapperCache.h"
30 #include <runtime/FunctionPrototype.h>
31 #include <runtime/JSCInlines.h>
32 #include <wtf/GetPtr.h>
33
34
35 namespace WebCore {
36 using namespace JSC;
37
38 // Attributes
39
40 JSC::EncodedJSValue jsTestNamedGetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
41 bool setJSTestNamedGetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
42
43 class JSTestNamedGetterNoIdentifierPrototype : public JSC::JSNonFinalObject {
44 public:
45     using Base = JSC::JSNonFinalObject;
46     static JSTestNamedGetterNoIdentifierPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
47     {
48         JSTestNamedGetterNoIdentifierPrototype* ptr = new (NotNull, JSC::allocateCell<JSTestNamedGetterNoIdentifierPrototype>(vm.heap)) JSTestNamedGetterNoIdentifierPrototype(vm, globalObject, structure);
49         ptr->finishCreation(vm);
50         return ptr;
51     }
52
53     DECLARE_INFO;
54     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
55     {
56         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
57     }
58
59 private:
60     JSTestNamedGetterNoIdentifierPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
61         : JSC::JSNonFinalObject(vm, structure)
62     {
63     }
64
65     void finishCreation(JSC::VM&);
66 };
67
68 using JSTestNamedGetterNoIdentifierConstructor = JSDOMConstructorNotConstructable<JSTestNamedGetterNoIdentifier>;
69
70 template<> JSValue JSTestNamedGetterNoIdentifierConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
71 {
72     UNUSED_PARAM(vm);
73     return globalObject.functionPrototype();
74 }
75
76 template<> void JSTestNamedGetterNoIdentifierConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
77 {
78     putDirect(vm, vm.propertyNames->prototype, JSTestNamedGetterNoIdentifier::prototype(vm, globalObject), JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
79     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestNamedGetterNoIdentifier"))), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
80     putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
81 }
82
83 template<> const ClassInfo JSTestNamedGetterNoIdentifierConstructor::s_info = { "TestNamedGetterNoIdentifier", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestNamedGetterNoIdentifierConstructor) };
84
85 /* Hash table for prototype */
86
87 static const HashTableValue JSTestNamedGetterNoIdentifierPrototypeTableValues[] =
88 {
89     { "constructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNamedGetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestNamedGetterNoIdentifierConstructor) } },
90 };
91
92 const ClassInfo JSTestNamedGetterNoIdentifierPrototype::s_info = { "TestNamedGetterNoIdentifierPrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestNamedGetterNoIdentifierPrototype) };
93
94 void JSTestNamedGetterNoIdentifierPrototype::finishCreation(VM& vm)
95 {
96     Base::finishCreation(vm);
97     reifyStaticProperties(vm, JSTestNamedGetterNoIdentifier::info(), JSTestNamedGetterNoIdentifierPrototypeTableValues, *this);
98 }
99
100 const ClassInfo JSTestNamedGetterNoIdentifier::s_info = { "TestNamedGetterNoIdentifier", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestNamedGetterNoIdentifier) };
101
102 JSTestNamedGetterNoIdentifier::JSTestNamedGetterNoIdentifier(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestNamedGetterNoIdentifier>&& impl)
103     : JSDOMWrapper<TestNamedGetterNoIdentifier>(structure, globalObject, WTFMove(impl))
104 {
105 }
106
107 void JSTestNamedGetterNoIdentifier::finishCreation(VM& vm)
108 {
109     Base::finishCreation(vm);
110     ASSERT(inherits(vm, info()));
111
112 }
113
114 JSObject* JSTestNamedGetterNoIdentifier::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
115 {
116     return JSTestNamedGetterNoIdentifierPrototype::create(vm, &globalObject, JSTestNamedGetterNoIdentifierPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
117 }
118
119 JSObject* JSTestNamedGetterNoIdentifier::prototype(VM& vm, JSDOMGlobalObject& globalObject)
120 {
121     return getDOMPrototype<JSTestNamedGetterNoIdentifier>(vm, globalObject);
122 }
123
124 JSValue JSTestNamedGetterNoIdentifier::getConstructor(VM& vm, const JSGlobalObject* globalObject)
125 {
126     return getDOMConstructor<JSTestNamedGetterNoIdentifierConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
127 }
128
129 void JSTestNamedGetterNoIdentifier::destroy(JSC::JSCell* cell)
130 {
131     JSTestNamedGetterNoIdentifier* thisObject = static_cast<JSTestNamedGetterNoIdentifier*>(cell);
132     thisObject->JSTestNamedGetterNoIdentifier::~JSTestNamedGetterNoIdentifier();
133 }
134
135 bool JSTestNamedGetterNoIdentifier::getOwnPropertySlot(JSObject* object, ExecState* state, PropertyName propertyName, PropertySlot& slot)
136 {
137     auto* thisObject = jsCast<JSTestNamedGetterNoIdentifier*>(object);
138     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
139     using GetterIDLType = IDLDOMString;
140     auto getterFunctor = [] (auto& thisObject, auto propertyName) -> std::optional<typename GetterIDLType::ImplementationType> {
141         auto result = thisObject.wrapped().namedItem(propertyNameToAtomicString(propertyName));
142         if (!GetterIDLType::isNullValue(result))
143             return typename GetterIDLType::ImplementationType { GetterIDLType::extractValueFromNullable(result) };
144         return std::nullopt;
145     };
146     if (auto namedProperty = accessVisibleNamedProperty<OverrideBuiltins::No>(*state, *thisObject, propertyName, getterFunctor)) {
147         auto value = toJS<IDLDOMString>(*state, WTFMove(namedProperty.value()));
148         slot.setValue(thisObject, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly), value);
149         return true;
150     }
151     return JSObject::getOwnPropertySlot(object, state, propertyName, slot);
152 }
153
154 bool JSTestNamedGetterNoIdentifier::getOwnPropertySlotByIndex(JSObject* object, ExecState* state, unsigned index, PropertySlot& slot)
155 {
156     auto* thisObject = jsCast<JSTestNamedGetterNoIdentifier*>(object);
157     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
158     auto propertyName = Identifier::from(state, index);
159     using GetterIDLType = IDLDOMString;
160     auto getterFunctor = [] (auto& thisObject, auto propertyName) -> std::optional<typename GetterIDLType::ImplementationType> {
161         auto result = thisObject.wrapped().namedItem(propertyNameToAtomicString(propertyName));
162         if (!GetterIDLType::isNullValue(result))
163             return typename GetterIDLType::ImplementationType { GetterIDLType::extractValueFromNullable(result) };
164         return std::nullopt;
165     };
166     if (auto namedProperty = accessVisibleNamedProperty<OverrideBuiltins::No>(*state, *thisObject, propertyName, getterFunctor)) {
167         auto value = toJS<IDLDOMString>(*state, WTFMove(namedProperty.value()));
168         slot.setValue(thisObject, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly), value);
169         return true;
170     }
171     return JSObject::getOwnPropertySlotByIndex(object, state, index, slot);
172 }
173
174 void JSTestNamedGetterNoIdentifier::getOwnPropertyNames(JSObject* object, ExecState* state, PropertyNameArray& propertyNames, EnumerationMode mode)
175 {
176     auto* thisObject = jsCast<JSTestNamedGetterNoIdentifier*>(object);
177     ASSERT_GC_OBJECT_INHERITS(object, info());
178     for (auto& propertyName : thisObject->wrapped().supportedPropertyNames())
179         propertyNames.add(Identifier::fromString(state, propertyName));
180     JSObject::getOwnPropertyNames(object, state, propertyNames, mode);
181 }
182
183 EncodedJSValue jsTestNamedGetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
184 {
185     VM& vm = state->vm();
186     auto throwScope = DECLARE_THROW_SCOPE(vm);
187     auto* prototype = jsDynamicDowncast<JSTestNamedGetterNoIdentifierPrototype*>(vm, JSValue::decode(thisValue));
188     if (UNLIKELY(!prototype))
189         return throwVMTypeError(state, throwScope);
190     return JSValue::encode(JSTestNamedGetterNoIdentifier::getConstructor(state->vm(), prototype->globalObject()));
191 }
192
193 bool setJSTestNamedGetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
194 {
195     VM& vm = state->vm();
196     auto throwScope = DECLARE_THROW_SCOPE(vm);
197     auto* prototype = jsDynamicDowncast<JSTestNamedGetterNoIdentifierPrototype*>(vm, JSValue::decode(thisValue));
198     if (UNLIKELY(!prototype)) {
199         throwVMTypeError(state, throwScope);
200         return false;
201     }
202     // Shadowing a built-in constructor
203     return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));
204 }
205
206 bool JSTestNamedGetterNoIdentifierOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
207 {
208     UNUSED_PARAM(handle);
209     UNUSED_PARAM(visitor);
210     return false;
211 }
212
213 void JSTestNamedGetterNoIdentifierOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
214 {
215     auto* jsTestNamedGetterNoIdentifier = static_cast<JSTestNamedGetterNoIdentifier*>(handle.slot()->asCell());
216     auto& world = *static_cast<DOMWrapperWorld*>(context);
217     uncacheWrapper(world, &jsTestNamedGetterNoIdentifier->wrapped(), jsTestNamedGetterNoIdentifier);
218 }
219
220 #if ENABLE(BINDING_INTEGRITY)
221 #if PLATFORM(WIN)
222 #pragma warning(disable: 4483)
223 extern "C" { extern void (*const __identifier("??_7TestNamedGetterNoIdentifier@WebCore@@6B@")[])(); }
224 #else
225 extern "C" { extern void* _ZTVN7WebCore27TestNamedGetterNoIdentifierE[]; }
226 #endif
227 #endif
228
229 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<TestNamedGetterNoIdentifier>&& impl)
230 {
231
232 #if ENABLE(BINDING_INTEGRITY)
233     void* actualVTablePointer = *(reinterpret_cast<void**>(impl.ptr()));
234 #if PLATFORM(WIN)
235     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestNamedGetterNoIdentifier@WebCore@@6B@"));
236 #else
237     void* expectedVTablePointer = &_ZTVN7WebCore27TestNamedGetterNoIdentifierE[2];
238 #endif
239
240     // If this fails TestNamedGetterNoIdentifier does not have a vtable, so you need to add the
241     // ImplementationLacksVTable attribute to the interface definition
242     static_assert(std::is_polymorphic<TestNamedGetterNoIdentifier>::value, "TestNamedGetterNoIdentifier is not polymorphic");
243
244     // If you hit this assertion you either have a use after free bug, or
245     // TestNamedGetterNoIdentifier has subclasses. If TestNamedGetterNoIdentifier has subclasses that get passed
246     // to toJS() we currently require TestNamedGetterNoIdentifier you to opt out of binding hardening
247     // by adding the SkipVTableValidation attribute to the interface IDL definition
248     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
249 #endif
250     return createWrapper<TestNamedGetterNoIdentifier>(globalObject, WTFMove(impl));
251 }
252
253 JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, TestNamedGetterNoIdentifier& impl)
254 {
255     return wrap(state, globalObject, impl);
256 }
257
258 TestNamedGetterNoIdentifier* JSTestNamedGetterNoIdentifier::toWrapped(JSC::VM& vm, JSC::JSValue value)
259 {
260     if (auto* wrapper = jsDynamicDowncast<JSTestNamedGetterNoIdentifier*>(vm, value))
261         return &wrapper->wrapped();
262     return nullptr;
263 }
264
265 }