Can't use Object.defineProperty() to add an item to a DOMStringMap or Storage
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestNamedSetterWithIdentifier.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 "JSTestNamedSetterWithIdentifier.h"
23
24 #include "JSDOMBinding.h"
25 #include "JSDOMConstructorNotConstructable.h"
26 #include "JSDOMConvert.h"
27 #include "JSDOMExceptionHandling.h"
28 #include "JSDOMOperation.h"
29 #include "JSDOMWrapperCache.h"
30 #include <runtime/FunctionPrototype.h>
31 #include <wtf/GetPtr.h>
32
33 using namespace JSC;
34
35 namespace WebCore {
36
37 // Functions
38
39 JSC::EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithIdentifierPrototypeFunctionNamedSetter(JSC::ExecState*);
40
41 // Attributes
42
43 JSC::EncodedJSValue jsTestNamedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
44 bool setJSTestNamedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
45
46 class JSTestNamedSetterWithIdentifierPrototype : public JSC::JSNonFinalObject {
47 public:
48     using Base = JSC::JSNonFinalObject;
49     static JSTestNamedSetterWithIdentifierPrototype* create(JSC::VM& vm, JSDOMGlobalObject* globalObject, JSC::Structure* structure)
50     {
51         JSTestNamedSetterWithIdentifierPrototype* ptr = new (NotNull, JSC::allocateCell<JSTestNamedSetterWithIdentifierPrototype>(vm.heap)) JSTestNamedSetterWithIdentifierPrototype(vm, globalObject, structure);
52         ptr->finishCreation(vm);
53         return ptr;
54     }
55
56     DECLARE_INFO;
57     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
58     {
59         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
60     }
61
62 private:
63     JSTestNamedSetterWithIdentifierPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
64         : JSC::JSNonFinalObject(vm, structure)
65     {
66     }
67
68     void finishCreation(JSC::VM&);
69 };
70
71 using JSTestNamedSetterWithIdentifierConstructor = JSDOMConstructorNotConstructable<JSTestNamedSetterWithIdentifier>;
72
73 template<> JSValue JSTestNamedSetterWithIdentifierConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
74 {
75     UNUSED_PARAM(vm);
76     return globalObject.functionPrototype();
77 }
78
79 template<> void JSTestNamedSetterWithIdentifierConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
80 {
81     putDirect(vm, vm.propertyNames->prototype, JSTestNamedSetterWithIdentifier::prototype(vm, globalObject), DontDelete | ReadOnly | DontEnum);
82     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestNamedSetterWithIdentifier"))), ReadOnly | DontEnum);
83     putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
84 }
85
86 template<> const ClassInfo JSTestNamedSetterWithIdentifierConstructor::s_info = { "TestNamedSetterWithIdentifier", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestNamedSetterWithIdentifierConstructor) };
87
88 /* Hash table for prototype */
89
90 static const HashTableValue JSTestNamedSetterWithIdentifierPrototypeTableValues[] =
91 {
92     { "constructor", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNamedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestNamedSetterWithIdentifierConstructor) } },
93     { "namedSetter", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestNamedSetterWithIdentifierPrototypeFunctionNamedSetter), (intptr_t) (2) } },
94 };
95
96 const ClassInfo JSTestNamedSetterWithIdentifierPrototype::s_info = { "TestNamedSetterWithIdentifierPrototype", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestNamedSetterWithIdentifierPrototype) };
97
98 void JSTestNamedSetterWithIdentifierPrototype::finishCreation(VM& vm)
99 {
100     Base::finishCreation(vm);
101     reifyStaticProperties(vm, JSTestNamedSetterWithIdentifierPrototypeTableValues, *this);
102 }
103
104 const ClassInfo JSTestNamedSetterWithIdentifier::s_info = { "TestNamedSetterWithIdentifier", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTestNamedSetterWithIdentifier) };
105
106 JSTestNamedSetterWithIdentifier::JSTestNamedSetterWithIdentifier(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestNamedSetterWithIdentifier>&& impl)
107     : JSDOMWrapper<TestNamedSetterWithIdentifier>(structure, globalObject, WTFMove(impl))
108 {
109 }
110
111 void JSTestNamedSetterWithIdentifier::finishCreation(VM& vm)
112 {
113     Base::finishCreation(vm);
114     ASSERT(inherits(vm, info()));
115
116 }
117
118 JSObject* JSTestNamedSetterWithIdentifier::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
119 {
120     return JSTestNamedSetterWithIdentifierPrototype::create(vm, &globalObject, JSTestNamedSetterWithIdentifierPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
121 }
122
123 JSObject* JSTestNamedSetterWithIdentifier::prototype(VM& vm, JSDOMGlobalObject& globalObject)
124 {
125     return getDOMPrototype<JSTestNamedSetterWithIdentifier>(vm, globalObject);
126 }
127
128 JSValue JSTestNamedSetterWithIdentifier::getConstructor(VM& vm, const JSGlobalObject* globalObject)
129 {
130     return getDOMConstructor<JSTestNamedSetterWithIdentifierConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
131 }
132
133 void JSTestNamedSetterWithIdentifier::destroy(JSC::JSCell* cell)
134 {
135     JSTestNamedSetterWithIdentifier* thisObject = static_cast<JSTestNamedSetterWithIdentifier*>(cell);
136     thisObject->JSTestNamedSetterWithIdentifier::~JSTestNamedSetterWithIdentifier();
137 }
138
139 bool JSTestNamedSetterWithIdentifier::getOwnPropertySlot(JSObject* object, ExecState* state, PropertyName propertyName, PropertySlot& slot)
140 {
141     auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(object);
142     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
143     if (Base::getOwnPropertySlot(thisObject, state, propertyName, slot))
144         return true;
145     JSValue proto = thisObject->getPrototypeDirect();
146     if (proto.isObject() && jsCast<JSObject*>(proto)->hasProperty(state, propertyName))
147         return false;
148
149     if (thisObject->classInfo() == info() && !propertyName.isSymbol()) {
150         auto item = thisObject->wrapped().namedItem(propertyNameToAtomicString(propertyName));
151         if (!IDLDOMString::isNullValue(item)) {
152             slot.setValue(thisObject, 0, toJS<IDLDOMString>(*state, item));
153             return true;
154         }
155     }
156     return false;
157 }
158
159 bool JSTestNamedSetterWithIdentifier::getOwnPropertySlotByIndex(JSObject* object, ExecState* state, unsigned index, PropertySlot& slot)
160 {
161     auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(object);
162     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
163     Identifier propertyName = Identifier::from(state, index);
164     if (thisObject->classInfo() == info()) {
165         auto item = thisObject->wrapped().namedItem(propertyNameToAtomicString(propertyName));
166         if (!IDLDOMString::isNullValue(item)) {
167             slot.setValue(thisObject, 0, toJS<IDLDOMString>(*state, item));
168             return true;
169         }
170     }
171     return Base::getOwnPropertySlotByIndex(thisObject, state, index, slot);
172 }
173
174 void JSTestNamedSetterWithIdentifier::getOwnPropertyNames(JSObject* object, ExecState* state, PropertyNameArray& propertyNames, EnumerationMode mode)
175 {
176     auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(object);
177     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
178     for (auto& propertyName : thisObject->wrapped().supportedPropertyNames())
179         propertyNames.add(Identifier::fromString(state, propertyName));
180     Base::getOwnPropertyNames(thisObject, state, propertyNames, mode);
181 }
182
183 bool JSTestNamedSetterWithIdentifier::put(JSCell* cell, ExecState* state, PropertyName propertyName, JSValue value, PutPropertySlot& putPropertySlot)
184 {
185     auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(cell);
186     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
187
188     if (!propertyName.isSymbol()) {
189         PropertySlot slot { thisObject, PropertySlot::InternalMethodType::VMInquiry };
190         JSValue prototype = thisObject->getPrototypeDirect();
191         if (!(prototype.isObject() && asObject(prototype)->getPropertySlot(state, propertyName, slot))) {
192             auto throwScope = DECLARE_THROW_SCOPE(state->vm());
193             auto nativeValue = convert<IDLDOMString>(*state, value);
194             RETURN_IF_EXCEPTION(throwScope, true);
195             thisObject->wrapped().namedSetter(propertyNameToString(propertyName), WTFMove(nativeValue));
196             return true;
197         }
198     }
199
200     return Base::put(thisObject, state, propertyName, value, putPropertySlot);
201 }
202
203 bool JSTestNamedSetterWithIdentifier::putByIndex(JSCell* cell, ExecState* state, unsigned index, JSValue value, bool shouldThrow)
204 {
205     auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(cell);
206     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
207
208     Identifier propertyName = Identifier::from(state, index);
209     PropertySlot slot { thisObject, PropertySlot::InternalMethodType::VMInquiry };
210     JSValue prototype = thisObject->getPrototypeDirect();
211     if (!(prototype.isObject() && asObject(prototype)->getPropertySlot(state, propertyName, slot))) {
212         auto throwScope = DECLARE_THROW_SCOPE(state->vm());
213         auto nativeValue = convert<IDLDOMString>(*state, value);
214         RETURN_IF_EXCEPTION(throwScope, true);
215         thisObject->wrapped().namedSetter(propertyNameToString(propertyName), WTFMove(nativeValue));
216         return true;
217     }
218
219     return Base::putByIndex(cell, state, index, value, shouldThrow);
220 }
221
222 bool JSTestNamedSetterWithIdentifier::defineOwnProperty(JSObject* object, ExecState* state, PropertyName propertyName, const PropertyDescriptor& propertyDescriptor, bool shouldThrow)
223 {
224     auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(object);
225     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
226
227     if (!propertyName.isSymbol()) {
228         PropertySlot slot { thisObject, PropertySlot::InternalMethodType::VMInquiry };
229         if (!Base::getOwnPropertySlot(thisObject, state, propertyName, slot)) {
230             if (!propertyDescriptor.isDataDescriptor())
231                 return false;
232             auto throwScope = DECLARE_THROW_SCOPE(state->vm());
233             auto nativeValue = convert<IDLDOMString>(*state, propertyDescriptor.value());
234             RETURN_IF_EXCEPTION(throwScope, true);
235             thisObject->wrapped().namedSetter(propertyNameToString(propertyName), WTFMove(nativeValue));
236             return true;
237         }
238     }
239
240     PropertyDescriptor newPropertyDescriptor = propertyDescriptor;
241     newPropertyDescriptor.setConfigurable(true);
242     return Base::defineOwnProperty(object, state, propertyName, newPropertyDescriptor, shouldThrow);
243 }
244
245 template<> inline JSTestNamedSetterWithIdentifier* IDLOperation<JSTestNamedSetterWithIdentifier>::cast(ExecState& state)
246 {
247     return jsDynamicDowncast<JSTestNamedSetterWithIdentifier*>(state.vm(), state.thisValue());
248 }
249
250 EncodedJSValue jsTestNamedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
251 {
252     VM& vm = state->vm();
253     auto throwScope = DECLARE_THROW_SCOPE(vm);
254     auto* prototype = jsDynamicDowncast<JSTestNamedSetterWithIdentifierPrototype*>(vm, JSValue::decode(thisValue));
255     if (UNLIKELY(!prototype))
256         return throwVMTypeError(state, throwScope);
257     return JSValue::encode(JSTestNamedSetterWithIdentifier::getConstructor(state->vm(), prototype->globalObject()));
258 }
259
260 bool setJSTestNamedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
261 {
262     VM& vm = state->vm();
263     auto throwScope = DECLARE_THROW_SCOPE(vm);
264     auto* prototype = jsDynamicDowncast<JSTestNamedSetterWithIdentifierPrototype*>(vm, JSValue::decode(thisValue));
265     if (UNLIKELY(!prototype)) {
266         throwVMTypeError(state, throwScope);
267         return false;
268     }
269     // Shadowing a built-in constructor
270     return prototype->putDirect(state->vm(), state->propertyNames().constructor, JSValue::decode(encodedValue));
271 }
272
273 static inline JSC::EncodedJSValue jsTestNamedSetterWithIdentifierPrototypeFunctionNamedSetterBody(JSC::ExecState* state, typename IDLOperation<JSTestNamedSetterWithIdentifier>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
274 {
275     UNUSED_PARAM(state);
276     UNUSED_PARAM(throwScope);
277     auto& impl = castedThis->wrapped();
278     if (UNLIKELY(state->argumentCount() < 2))
279         return throwVMError(state, throwScope, createNotEnoughArgumentsError(state));
280     auto name = convert<IDLDOMString>(*state, state->uncheckedArgument(0));
281     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
282     auto value = convert<IDLDOMString>(*state, state->uncheckedArgument(1));
283     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
284     impl.namedSetter(WTFMove(name), WTFMove(value));
285     return JSValue::encode(jsUndefined());
286 }
287
288 EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithIdentifierPrototypeFunctionNamedSetter(ExecState* state)
289 {
290     return IDLOperation<JSTestNamedSetterWithIdentifier>::call<jsTestNamedSetterWithIdentifierPrototypeFunctionNamedSetterBody>(*state, "namedSetter");
291 }
292
293 bool JSTestNamedSetterWithIdentifierOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
294 {
295     UNUSED_PARAM(handle);
296     UNUSED_PARAM(visitor);
297     return false;
298 }
299
300 void JSTestNamedSetterWithIdentifierOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
301 {
302     auto* jsTestNamedSetterWithIdentifier = static_cast<JSTestNamedSetterWithIdentifier*>(handle.slot()->asCell());
303     auto& world = *static_cast<DOMWrapperWorld*>(context);
304     uncacheWrapper(world, &jsTestNamedSetterWithIdentifier->wrapped(), jsTestNamedSetterWithIdentifier);
305 }
306
307 #if ENABLE(BINDING_INTEGRITY)
308 #if PLATFORM(WIN)
309 #pragma warning(disable: 4483)
310 extern "C" { extern void (*const __identifier("??_7TestNamedSetterWithIdentifier@WebCore@@6B@")[])(); }
311 #else
312 extern "C" { extern void* _ZTVN7WebCore29TestNamedSetterWithIdentifierE[]; }
313 #endif
314 #endif
315
316 JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject* globalObject, Ref<TestNamedSetterWithIdentifier>&& impl)
317 {
318
319 #if ENABLE(BINDING_INTEGRITY)
320     void* actualVTablePointer = *(reinterpret_cast<void**>(impl.ptr()));
321 #if PLATFORM(WIN)
322     void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestNamedSetterWithIdentifier@WebCore@@6B@"));
323 #else
324     void* expectedVTablePointer = &_ZTVN7WebCore29TestNamedSetterWithIdentifierE[2];
325 #if COMPILER(CLANG)
326     // If this fails TestNamedSetterWithIdentifier does not have a vtable, so you need to add the
327     // ImplementationLacksVTable attribute to the interface definition
328     static_assert(__is_polymorphic(TestNamedSetterWithIdentifier), "TestNamedSetterWithIdentifier is not polymorphic");
329 #endif
330 #endif
331     // If you hit this assertion you either have a use after free bug, or
332     // TestNamedSetterWithIdentifier has subclasses. If TestNamedSetterWithIdentifier has subclasses that get passed
333     // to toJS() we currently require TestNamedSetterWithIdentifier you to opt out of binding hardening
334     // by adding the SkipVTableValidation attribute to the interface IDL definition
335     RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
336 #endif
337     return createWrapper<TestNamedSetterWithIdentifier>(globalObject, WTFMove(impl));
338 }
339
340 JSC::JSValue toJS(JSC::ExecState* state, JSDOMGlobalObject* globalObject, TestNamedSetterWithIdentifier& impl)
341 {
342     return wrap(state, globalObject, impl);
343 }
344
345 TestNamedSetterWithIdentifier* JSTestNamedSetterWithIdentifier::toWrapped(JSC::VM& vm, JSC::JSValue value)
346 {
347     if (auto* wrapper = jsDynamicDowncast<JSTestNamedSetterWithIdentifier*>(vm, value))
348         return &wrapper->wrapped();
349     return nullptr;
350 }
351
352 }