Next batch of conversions to use C++ enum class instead of strings for enumerations
[WebKit-https.git] / Source / WebCore / bindings / scripts / test / JS / JSTestObj.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 "JSTestObj.h"
23
24 #include "CallbackFunction.h"
25 #include "DOMStringList.h"
26 #include "Dictionary.h"
27 #include "Document.h"
28 #include "ExceptionCode.h"
29 #include "Frame.h"
30 #include "HTMLNames.h"
31 #include "JSDOMBinding.h"
32 #include "JSDOMConstructor.h"
33 #include "JSDOMPromise.h"
34 #include "JSDOMStringList.h"
35 #include "JSDocument.h"
36 #include "JSEventListener.h"
37 #include "JSFetchRequest.h"
38 #include "JSKeyValueIterator.h"
39 #include "JSNode.h"
40 #include "JSSVGDocument.h"
41 #include "JSSVGPoint.h"
42 #include "JSScriptProfile.h"
43 #include "JSTestCallback.h"
44 #include "JSTestCallbackFunction.h"
45 #include "JSTestNode.h"
46 #include "JSTestObj.h"
47 #include "JSTestSubObj.h"
48 #include "JSbool.h"
49 #include "LifecycleCallbackQueue.h"
50 #include "RuntimeEnabledFeatures.h"
51 #include "SVGDocument.h"
52 #include "SVGPoint.h"
53 #include "SVGStaticPropertyTearOff.h"
54 #include "ScriptProfile.h"
55 #include "SerializedScriptValue.h"
56 #include "Settings.h"
57 #include "TestNode.h"
58 #include "TestObj.h"
59 #include "URL.h"
60 #include "WebCoreJSClientData.h"
61 #include "bool.h"
62 #include <inspector/ScriptArguments.h>
63 #include <inspector/ScriptCallStackFactory.h>
64 #include <runtime/Error.h>
65 #include <runtime/FunctionPrototype.h>
66 #include <runtime/JSArray.h>
67 #include <runtime/JSString.h>
68 #include <runtime/PropertyNameArray.h>
69 #include <runtime/Symbol.h>
70 #include <wtf/GetPtr.h>
71
72 #if ENABLE(Condition1)
73 #include "JSTestObjectA.h"
74 #endif
75
76 #if ENABLE(Condition1) && ENABLE(Condition2)
77 #include "JSTestObjectB.h"
78 #endif
79
80 #if ENABLE(Condition1) || ENABLE(Condition2)
81 #include "JSTestObjectC.h"
82 #endif
83
84 #if ENABLE(Condition3) || ENABLE(Condition4)
85 #include "TestObjBuiltins.h"
86 #endif
87
88 using namespace JSC;
89
90 namespace WebCore {
91
92 JSString* jsStringWithCache(ExecState*, TestEnumType);
93 Optional<TestEnumType> parseTestEnumType(ExecState&, JSValue);
94 extern const char* const expectedEnumerationValuesTestEnumType;
95
96 JSString* jsStringWithCache(ExecState* state, TestEnumType enumerationValue)
97 {
98     static NeverDestroyed<const String> values[] = {
99         ASCIILiteral(""),
100         ASCIILiteral("EnumValue1"),
101         ASCIILiteral("EnumValue2"),
102         ASCIILiteral("EnumValue3"),
103     };
104     static_assert(static_cast<size_t>(TestEnumType::EmptyString) == 0, "TestEnumType::EmptyString is not 0 as expected");
105     static_assert(static_cast<size_t>(TestEnumType::EnumValue1) == 1, "TestEnumType::EnumValue1 is not 1 as expected");
106     static_assert(static_cast<size_t>(TestEnumType::EnumValue2) == 2, "TestEnumType::EnumValue2 is not 2 as expected");
107     static_assert(static_cast<size_t>(TestEnumType::EnumValue3) == 3, "TestEnumType::EnumValue3 is not 3 as expected");
108     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
109     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
110 }
111
112 template<> struct JSValueTraits<TestEnumType> {
113     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, TestEnumType value) { return jsStringWithCache(state, value); }
114 };
115
116 Optional<TestEnumType> parseTestEnumType(ExecState& state, JSValue value)
117 {
118     auto stringValue = value.toWTFString(&state);
119     if (stringValue.isEmpty())
120         return TestEnumType::EmptyString;
121     if (stringValue == "EnumValue1")
122         return TestEnumType::EnumValue1;
123     if (stringValue == "EnumValue2")
124         return TestEnumType::EnumValue2;
125     if (stringValue == "EnumValue3")
126         return TestEnumType::EnumValue3;
127     return Nullopt;
128 }
129
130 const char* const expectedEnumerationValuesTestEnumType = "\"\", \"EnumValue1\", \"EnumValue2\", \"EnumValue3\"";
131
132 JSString* jsStringWithCache(ExecState*, Optional);
133 Optional<Optional> parseOptional(ExecState&, JSValue);
134 extern const char* const expectedEnumerationValuesOptional;
135
136 JSString* jsStringWithCache(ExecState* state, Optional enumerationValue)
137 {
138     static NeverDestroyed<const String> values[] = {
139         ASCIILiteral(""),
140         ASCIILiteral("OptionalValue1"),
141         ASCIILiteral("OptionalValue2"),
142         ASCIILiteral("OptionalValue3"),
143     };
144     static_assert(static_cast<size_t>(Optional::EmptyString) == 0, "Optional::EmptyString is not 0 as expected");
145     static_assert(static_cast<size_t>(Optional::OptionalValue1) == 1, "Optional::OptionalValue1 is not 1 as expected");
146     static_assert(static_cast<size_t>(Optional::OptionalValue2) == 2, "Optional::OptionalValue2 is not 2 as expected");
147     static_assert(static_cast<size_t>(Optional::OptionalValue3) == 3, "Optional::OptionalValue3 is not 3 as expected");
148     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
149     return jsStringWithCache(state, values[static_cast<size_t>(enumerationValue)]);
150 }
151
152 template<> struct JSValueTraits<Optional> {
153     static JSString* arrayJSValue(ExecState* state, JSDOMGlobalObject*, Optional value) { return jsStringWithCache(state, value); }
154 };
155
156 Optional<Optional> parseOptional(ExecState& state, JSValue value)
157 {
158     auto stringValue = value.toWTFString(&state);
159     if (stringValue.isEmpty())
160         return Optional::EmptyString;
161     if (stringValue == "OptionalValue1")
162         return Optional::OptionalValue1;
163     if (stringValue == "OptionalValue2")
164         return Optional::OptionalValue2;
165     if (stringValue == "OptionalValue3")
166         return Optional::OptionalValue3;
167     return Nullopt;
168 }
169
170 const char* const expectedEnumerationValuesOptional = "\"\", \"OptionalValue1\", \"OptionalValue2\", \"OptionalValue3\"";
171
172 // Functions
173
174 #if ENABLE(TEST_FEATURE)
175 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionEnabledAtRuntimeOperation(JSC::ExecState*);
176 #endif
177 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethod(JSC::ExecState*);
178 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVoidMethodWithArgs(JSC::ExecState*);
179 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethod(JSC::ExecState*);
180 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethodWithArgs(JSC::ExecState*);
181 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethod(JSC::ExecState*);
182 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethodWithArgs(JSC::ExecState*);
183 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(JSC::ExecState*);
184 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(JSC::ExecState*);
185 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(JSC::ExecState*);
186 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(JSC::ExecState*);
187 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjInstanceFunctionUnforgeableMethod(JSC::ExecState*);
188 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithArgTreatingNullAsEmptyString(JSC::ExecState*);
189 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionNullableStringMethod(JSC::ExecState*);
190 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionNullableStringStaticMethod(JSC::ExecState*);
191 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionNullableStringSpecialMethod(JSC::ExecState*);
192 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithSequenceArg(JSC::ExecState*);
193 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodReturningSequence(JSC::ExecState*);
194 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithEnumArg(JSC::ExecState*);
195 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalEnumArgAndDefaultValue(JSC::ExecState*);
196 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows(JSC::ExecState*);
197 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSerializedValue(JSC::ExecState*);
198 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOptionsObject(JSC::ExecState*);
199 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithException(JSC::ExecState*);
200 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithExceptionWithMessage(JSC::ExecState*);
201 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethod(JSC::ExecState*);
202 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCustomMethodWithArgs(JSC::ExecState*);
203 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionPrivateMethod(JSC::ExecState*);
204 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAddEventListener(JSC::ExecState*);
205 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionRemoveEventListener(JSC::ExecState*);
206 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoid(JSC::ExecState*);
207 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(JSC::ExecState*);
208 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateVoidException(JSC::ExecState*);
209 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjException(JSC::ExecState*);
210 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContext(JSC::ExecState*);
211 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState(JSC::ExecState*);
212 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException(JSC::ExecState*);
213 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces(JSC::ExecState*);
214 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack(JSC::ExecState*);
215 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithDocumentArgument(JSC::ExecState*);
216 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArg(JSC::ExecState*);
217 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArgAndDefaultValue(JSC::ExecState*);
218 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg(JSC::ExecState*);
219 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs(JSC::ExecState*);
220 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalString(JSC::ExecState*);
221 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicString(JSC::ExecState*);
222 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue(JSC::ExecState*);
223 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue(JSC::ExecState*);
224 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull(JSC::ExecState*);
225 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined(JSC::ExecState*);
226 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull(JSC::ExecState*);
227 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString(JSC::ExecState*);
228 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString(JSC::ExecState*);
229 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN(JSC::ExecState*);
230 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN(JSC::ExecState*);
231 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalSequence(JSC::ExecState*);
232 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalLongLong(JSC::ExecState*);
233 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalLongLongIsZero(JSC::ExecState*);
234 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLong(JSC::ExecState*);
235 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLongIsZero(JSC::ExecState*);
236 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArray(JSC::ExecState*);
237 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalArrayIsEmpty(JSC::ExecState*);
238 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalBoolean(JSC::ExecState*);
239 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalBooleanIsFalse(JSC::ExecState*);
240 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAny(JSC::ExecState*);
241 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapper(JSC::ExecState*);
242 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapperIsNull(JSC::ExecState*);
243 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackArg(JSC::ExecState*);
244 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg(JSC::ExecState*);
245 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg(JSC::ExecState*);
246 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackFunctionArg(JSC::ExecState*);
247 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackFunctionArg(JSC::ExecState*);
248 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithCallbackFunctionAndOptionalArg(JSC::ExecState*);
249 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg(JSC::ExecState*);
250 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionStaticMethodWithCallbackArg(JSC::ExecState*);
251 #if ENABLE(Condition1)
252 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod1(JSC::ExecState*);
253 #endif
254 #if ENABLE(Condition1) && ENABLE(Condition2)
255 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod2(JSC::ExecState*);
256 #endif
257 #if ENABLE(Condition1) || ENABLE(Condition2)
258 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod3(JSC::ExecState*);
259 #endif
260 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethod(JSC::ExecState*);
261 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOverloadedMethodWithOptionalParameter(JSC::ExecState*);
262 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethod(JSC::ExecState*);
263 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethodWithOptional(JSC::ExecState*);
264 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethod2(JSC::ExecState*);
265 #if ENABLE(Condition1)
266 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionOverloadedMethod1(JSC::ExecState*);
267 #endif
268 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionClassMethodWithClamp(JSC::ExecState*);
269 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionClassMethodWithEnforceRange(JSC::ExecState*);
270 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence(JSC::ExecState*);
271 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStringArrayFunction(JSC::ExecState*);
272 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionDomStringListFunction(JSC::ExecState*);
273 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence(JSC::ExecState*);
274 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence2(JSC::ExecState*);
275 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionGetSVGDocument(JSC::ExecState*);
276 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert1(JSC::ExecState*);
277 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert2(JSC::ExecState*);
278 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert3(JSC::ExecState*);
279 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConvert4(JSC::ExecState*);
280 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMutablePointFunction(JSC::ExecState*);
281 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionImmutablePointFunction(JSC::ExecState*);
282 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOrange(JSC::ExecState*);
283 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunction(JSC::ExecState*);
284 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithSequence(JSC::ExecState*);
285 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithArray(JSC::ExecState*);
286 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicStringMethod(JSC::ExecState*);
287 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicDoubleMethod(JSC::ExecState*);
288 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionVariadicNodeMethod(JSC::ExecState*);
289 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAny(JSC::ExecState*);
290 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(JSC::ExecState*);
291 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(JSC::ExecState*);
292 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(JSC::ExecState*);
293 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(JSC::ExecState*);
294 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunction(JSC::ExecState*);
295 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(JSC::ExecState*);
296 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(JSC::ExecState*);
297 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithNeedsLifecycleProcessingStack(JSC::ExecState*);
298 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionSymbolIterator(JSC::ExecState*);
299 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionEntries(JSC::ExecState*);
300 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionKeys(JSC::ExecState*);
301 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionValues(JSC::ExecState*);
302 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionForEach(JSC::ExecState*);
303
304 // Attributes
305
306 JSC::EncodedJSValue jsTestObjReadOnlyLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
307 JSC::EncodedJSValue jsTestObjReadOnlyStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
308 JSC::EncodedJSValue jsTestObjReadOnlyTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
309 JSC::EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
310 JSC::EncodedJSValue jsTestObjConstructorStaticStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
311 bool setJSTestObjConstructorStaticStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
312 JSC::EncodedJSValue jsTestObjConstructorTestSubObj(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
313 JSC::EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
314 bool setJSTestObjTestSubObjEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
315 JSC::EncodedJSValue jsTestObjEnumAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
316 bool setJSTestObjEnumAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
317 JSC::EncodedJSValue jsTestObjByteAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
318 bool setJSTestObjByteAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
319 JSC::EncodedJSValue jsTestObjOctetAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
320 bool setJSTestObjOctetAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
321 JSC::EncodedJSValue jsTestObjShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
322 bool setJSTestObjShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
323 JSC::EncodedJSValue jsTestObjClampedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
324 bool setJSTestObjClampedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
325 JSC::EncodedJSValue jsTestObjEnforceRangeShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
326 bool setJSTestObjEnforceRangeShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
327 JSC::EncodedJSValue jsTestObjUnsignedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
328 bool setJSTestObjUnsignedShortAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
329 JSC::EncodedJSValue jsTestObjLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
330 bool setJSTestObjLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
331 JSC::EncodedJSValue jsTestObjLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
332 bool setJSTestObjLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
333 JSC::EncodedJSValue jsTestObjUnsignedLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
334 bool setJSTestObjUnsignedLongLongAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
335 JSC::EncodedJSValue jsTestObjStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
336 bool setJSTestObjStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
337 JSC::EncodedJSValue jsTestObjTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
338 bool setJSTestObjTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
339 JSC::EncodedJSValue jsTestObjLenientTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
340 bool setJSTestObjLenientTestObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
341 JSC::EncodedJSValue jsTestObjUnforgeableAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
342 JSC::EncodedJSValue jsTestObjStringAttrTreatingNullAsEmptyString(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
343 bool setJSTestObjStringAttrTreatingNullAsEmptyString(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
344 JSC::EncodedJSValue jsTestObjXMLObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
345 bool setJSTestObjXMLObjAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
346 JSC::EncodedJSValue jsTestObjCreate(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
347 bool setJSTestObjCreate(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
348 JSC::EncodedJSValue jsTestObjReadOnlySymbolAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
349 JSC::EncodedJSValue jsTestObjConstructorStaticReadOnlySymbolAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
350 JSC::EncodedJSValue jsTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
351 bool setJSTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
352 JSC::EncodedJSValue jsTestObjReflectedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
353 bool setJSTestObjReflectedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
354 JSC::EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
355 bool setJSTestObjReflectedUnsignedIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
356 JSC::EncodedJSValue jsTestObjReflectedBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
357 bool setJSTestObjReflectedBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
358 JSC::EncodedJSValue jsTestObjReflectedURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
359 bool setJSTestObjReflectedURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
360 JSC::EncodedJSValue jsTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
361 bool setJSTestObjReflectedStringAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
362 JSC::EncodedJSValue jsTestObjReflectedCustomIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
363 bool setJSTestObjReflectedCustomIntegralAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
364 JSC::EncodedJSValue jsTestObjReflectedCustomBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
365 bool setJSTestObjReflectedCustomBooleanAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
366 JSC::EncodedJSValue jsTestObjReflectedCustomURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
367 bool setJSTestObjReflectedCustomURLAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
368 #if ENABLE(TEST_FEATURE)
369 JSC::EncodedJSValue jsTestObjEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
370 bool setJSTestObjEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
371 #endif
372 JSC::EncodedJSValue jsTestObjTypedArrayAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
373 bool setJSTestObjTypedArrayAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
374 JSC::EncodedJSValue jsTestObjAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
375 bool setJSTestObjAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
376 JSC::EncodedJSValue jsTestObjAttrWithGetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
377 bool setJSTestObjAttrWithGetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
378 JSC::EncodedJSValue jsTestObjAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
379 bool setJSTestObjAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
380 JSC::EncodedJSValue jsTestObjAttrWithSetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
381 bool setJSTestObjAttrWithSetterExceptionWithMessage(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
382 JSC::EncodedJSValue jsTestObjStringAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
383 bool setJSTestObjStringAttrWithGetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
384 JSC::EncodedJSValue jsTestObjStringAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
385 bool setJSTestObjStringAttrWithSetterException(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
386 JSC::EncodedJSValue jsTestObjStrictTypeCheckingAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
387 bool setJSTestObjStrictTypeCheckingAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
388 JSC::EncodedJSValue jsTestObjCustomAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
389 bool setJSTestObjCustomAttr(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
390 JSC::EncodedJSValue jsTestObjOnfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
391 bool setJSTestObjOnfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
392 JSC::EncodedJSValue jsTestObjOnwebkitfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
393 bool setJSTestObjOnwebkitfoo(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
394 JSC::EncodedJSValue jsTestObjWithScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
395 bool setJSTestObjWithScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
396 JSC::EncodedJSValue jsTestObjWithCallWithAndSetterCallWithAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
397 bool setJSTestObjWithCallWithAndSetterCallWithAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
398 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
399 bool setJSTestObjWithScriptExecutionContextAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
400 JSC::EncodedJSValue jsTestObjWithScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
401 bool setJSTestObjWithScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
402 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
403 bool setJSTestObjWithScriptExecutionContextAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
404 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
405 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
406 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
407 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
408 JSC::EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
409 bool setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
410 JSC::EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
411 bool setJSTestObjWithScriptArgumentsAndCallStackAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
412 #if ENABLE(Condition1)
413 JSC::EncodedJSValue jsTestObjConditionalAttr1(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
414 bool setJSTestObjConditionalAttr1(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
415 #endif
416 #if ENABLE(Condition1) && ENABLE(Condition2)
417 JSC::EncodedJSValue jsTestObjConditionalAttr2(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
418 bool setJSTestObjConditionalAttr2(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
419 #endif
420 #if ENABLE(Condition1) || ENABLE(Condition2)
421 JSC::EncodedJSValue jsTestObjConditionalAttr3(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
422 bool setJSTestObjConditionalAttr3(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
423 #endif
424 #if ENABLE(Condition1)
425 JSC::EncodedJSValue jsTestObjConditionalAttr4Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
426 bool setJSTestObjConditionalAttr4Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
427 #endif
428 #if ENABLE(Condition1) && ENABLE(Condition2)
429 JSC::EncodedJSValue jsTestObjConditionalAttr5Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
430 bool setJSTestObjConditionalAttr5Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
431 #endif
432 #if ENABLE(Condition1) || ENABLE(Condition2)
433 JSC::EncodedJSValue jsTestObjConditionalAttr6Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
434 bool setJSTestObjConditionalAttr6Constructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
435 #endif
436 JSC::EncodedJSValue jsTestObjCachedAttribute1(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
437 JSC::EncodedJSValue jsTestObjCachedAttribute2(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
438 JSC::EncodedJSValue jsTestObjAnyAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
439 bool setJSTestObjAnyAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
440 JSC::EncodedJSValue jsTestObjContentDocument(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
441 JSC::EncodedJSValue jsTestObjMutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
442 bool setJSTestObjMutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
443 JSC::EncodedJSValue jsTestObjImmutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
444 bool setJSTestObjImmutablePoint(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
445 JSC::EncodedJSValue jsTestObjStrawberry(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
446 bool setJSTestObjStrawberry(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
447 JSC::EncodedJSValue jsTestObjStrictFloat(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
448 bool setJSTestObjStrictFloat(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
449 JSC::EncodedJSValue jsTestObjDescription(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
450 JSC::EncodedJSValue jsTestObjId(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
451 bool setJSTestObjId(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
452 JSC::EncodedJSValue jsTestObjHash(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
453 JSC::EncodedJSValue jsTestObjReplaceableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
454 bool setJSTestObjReplaceableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
455 JSC::EncodedJSValue jsTestObjNullableDoubleAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
456 JSC::EncodedJSValue jsTestObjNullableLongAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
457 JSC::EncodedJSValue jsTestObjNullableBooleanAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
458 JSC::EncodedJSValue jsTestObjNullableStringAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
459 JSC::EncodedJSValue jsTestObjNullableLongSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
460 bool setJSTestObjNullableLongSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
461 JSC::EncodedJSValue jsTestObjNullableStringSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
462 bool setJSTestObjNullableStringSettableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
463 JSC::EncodedJSValue jsTestObjNullableStringValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
464 bool setJSTestObjNullableStringValue(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
465 JSC::EncodedJSValue jsTestObjAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
466 JSC::EncodedJSValue jsTestObjAttributeWithReservedEnumType(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
467 bool setJSTestObjAttributeWithReservedEnumType(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
468 JSC::EncodedJSValue jsTestObjPutForwardsAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
469 bool setJSTestObjPutForwardsAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
470 JSC::EncodedJSValue jsTestObjPutForwardsNullableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
471 bool setJSTestObjPutForwardsNullableAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
472 JSC::EncodedJSValue jsTestObjConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
473 bool setJSTestObjConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
474
475 class JSTestObjPrototype : public JSC::JSNonFinalObject {
476 public:
477     typedef JSC::JSNonFinalObject Base;
478     static JSTestObjPrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
479     {
480         JSTestObjPrototype* ptr = new (NotNull, JSC::allocateCell<JSTestObjPrototype>(vm.heap)) JSTestObjPrototype(vm, globalObject, structure);
481         ptr->finishCreation(vm);
482         return ptr;
483     }
484
485     DECLARE_INFO;
486     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
487     {
488         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
489     }
490
491 private:
492     JSTestObjPrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure)
493         : JSC::JSNonFinalObject(vm, structure)
494     {
495     }
496
497     void finishCreation(JSC::VM&);
498 };
499
500 typedef JSDOMConstructor<JSTestObj> JSTestObjConstructor;
501
502 /* Hash table */
503
504 static const struct CompactHashIndex JSTestObjTableIndex[17] = {
505     { -1, -1 },
506     { -1, -1 },
507     { 5, -1 },
508     { -1, -1 },
509     { -1, -1 },
510     { -1, -1 },
511     { 4, -1 },
512     { -1, -1 },
513     { 1, -1 },
514     { 2, -1 },
515     { 0, 16 },
516     { -1, -1 },
517     { -1, -1 },
518     { -1, -1 },
519     { -1, -1 },
520     { -1, -1 },
521     { 3, -1 },
522 };
523
524
525 static const HashTableValue JSTestObjTableValues[] =
526 {
527     { "TestSubObjEnabledBySetting", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestSubObjEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestSubObjEnabledBySettingConstructor) } },
528     { "unforgeableAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnforgeableAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
529 #if ENABLE(Condition1)
530     { "conditionalAttr4", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr4Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr4Constructor) } },
531 #else
532     { 0, 0, NoIntrinsic, { 0, 0 } },
533 #endif
534 #if ENABLE(Condition1) && ENABLE(Condition2)
535     { "conditionalAttr5", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr5Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr5Constructor) } },
536 #else
537     { 0, 0, NoIntrinsic, { 0, 0 } },
538 #endif
539 #if ENABLE(Condition1) || ENABLE(Condition2)
540     { "conditionalAttr6", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr6Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr6Constructor) } },
541 #else
542     { 0, 0, NoIntrinsic, { 0, 0 } },
543 #endif
544     { "unforgeableMethod", DontDelete | ReadOnly | JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjInstanceFunctionUnforgeableMethod), (intptr_t) (0) } },
545 };
546
547 static const HashTable JSTestObjTable = { 6, 15, true, JSTestObjTableValues, JSTestObjTableIndex };
548 /* Hash table for constructor */
549
550 static const HashTableValue JSTestObjConstructorTableValues[] =
551 {
552 #if ENABLE(Condition1)
553     { "CONDITIONAL_CONST", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
554 #else
555     { 0, 0, NoIntrinsic, { 0, 0 } },
556 #endif
557     { "CONST_VALUE_0", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
558     { "CONST_VALUE_1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
559     { "CONST_VALUE_2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
560     { "CONST_VALUE_4", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(4) } },
561     { "CONST_VALUE_8", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(8) } },
562     { "CONST_VALUE_9", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(-1) } },
563     { "CONST_VALUE_11", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0xffffffff) } },
564     { "CONST_VALUE_12", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x01) } },
565     { "CONST_VALUE_13", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0X20) } },
566     { "CONST_VALUE_14", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x1abc) } },
567     { "CONST_JAVASCRIPT", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(15) } },
568     { "readonly", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
569     { "staticReadOnlyLongAttr", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
570     { "staticStringAttr", DontDelete, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructorStaticStringAttr) } },
571     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
572     { "staticReadOnlySymbolAttr", DontDelete | ReadOnly, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructorStaticReadOnlySymbolAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
573     { "nullableStringStaticMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionNullableStringStaticMethod), (intptr_t) (0) } },
574     { "staticMethodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackAndOptionalArg), (intptr_t) (0) } },
575     { "staticMethodWithCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionStaticMethodWithCallbackArg), (intptr_t) (1) } },
576     { "classMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod), (intptr_t) (0) } },
577     { "classMethodWithOptional", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethodWithOptional), (intptr_t) (0) } },
578     { "classMethod2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod2), (intptr_t) (1) } },
579 #if ENABLE(Condition1)
580     { "overloadedMethod1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionOverloadedMethod1), (intptr_t) (1) } },
581 #else
582     { 0, 0, NoIntrinsic, { 0, 0 } },
583 #endif
584     { "testStaticPromiseFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionTestStaticPromiseFunction), (intptr_t) (0) } },
585     { "testStaticPromiseFunctionWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException), (intptr_t) (0) } },
586 };
587
588
589 #if ENABLE(Condition1)
590 COMPILE_ASSERT(0 == TestObj::CONDITIONAL_CONST, TestObjEnumCONDITIONAL_CONSTIsWrongUseDoNotCheckConstants);
591 #endif
592 COMPILE_ASSERT(0 == TestObj::CONST_VALUE_0, TestObjEnumCONST_VALUE_0IsWrongUseDoNotCheckConstants);
593 COMPILE_ASSERT(1 == TestObj::CONST_VALUE_1, TestObjEnumCONST_VALUE_1IsWrongUseDoNotCheckConstants);
594 COMPILE_ASSERT(2 == TestObj::CONST_VALUE_2, TestObjEnumCONST_VALUE_2IsWrongUseDoNotCheckConstants);
595 COMPILE_ASSERT(4 == TestObj::CONST_VALUE_4, TestObjEnumCONST_VALUE_4IsWrongUseDoNotCheckConstants);
596 COMPILE_ASSERT(8 == TestObj::CONST_VALUE_8, TestObjEnumCONST_VALUE_8IsWrongUseDoNotCheckConstants);
597 COMPILE_ASSERT(-1 == TestObj::CONST_VALUE_9, TestObjEnumCONST_VALUE_9IsWrongUseDoNotCheckConstants);
598 COMPILE_ASSERT(0xffffffff == TestObj::CONST_VALUE_11, TestObjEnumCONST_VALUE_11IsWrongUseDoNotCheckConstants);
599 COMPILE_ASSERT(0x01 == TestObj::CONST_VALUE_12, TestObjEnumCONST_VALUE_12IsWrongUseDoNotCheckConstants);
600 COMPILE_ASSERT(0X20 == TestObj::CONST_VALUE_13, TestObjEnumCONST_VALUE_13IsWrongUseDoNotCheckConstants);
601 COMPILE_ASSERT(0x1abc == TestObj::CONST_VALUE_14, TestObjEnumCONST_VALUE_14IsWrongUseDoNotCheckConstants);
602 COMPILE_ASSERT(15 == TestObj::CONST_IMPL, TestObjEnumCONST_IMPLIsWrongUseDoNotCheckConstants);
603 COMPILE_ASSERT(0 == TestObj::readonly, TestObjEnumreadonlyIsWrongUseDoNotCheckConstants);
604
605 template<> EncodedJSValue JSC_HOST_CALL JSTestObjConstructor::construct(ExecState* state)
606 {
607     auto* castedThis = jsCast<JSTestObjConstructor*>(state->callee());
608     if (UNLIKELY(state->argumentCount() < 2))
609         return throwVMError(state, createNotEnoughArgumentsError(state));
610     if (UNLIKELY(!state->argument(0).isObject()))
611         return throwArgumentMustBeFunctionError(*state, 0, "testCallback", "TestObj", nullptr);
612     RefPtr<TestCallback> testCallback = JSTestCallback::create(asObject(state->uncheckedArgument(0)), castedThis->globalObject());
613     if (UNLIKELY(!state->argument(1).isFunction()))
614         return throwArgumentMustBeFunctionError(*state, 1, "testCallbackFunction", "TestObj", nullptr);
615     RefPtr<TestCallbackFunction> testCallbackFunction = JSTestCallbackFunction::create(asObject(state->uncheckedArgument(1)), castedThis->globalObject());
616     RefPtr<TestObj> object = TestObj::create(*testCallback, *testCallbackFunction);
617     return JSValue::encode(asObject(toJS(state, castedThis->globalObject(), object.get())));
618 }
619
620 template<> JSValue JSTestObjConstructor::prototypeForStructure(JSC::VM& vm, const JSDOMGlobalObject& globalObject)
621 {
622     UNUSED_PARAM(vm);
623     return globalObject.functionPrototype();
624 }
625
626 template<> void JSTestObjConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
627 {
628     putDirect(vm, vm.propertyNames->prototype, JSTestObj::prototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
629     putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestObject"))), ReadOnly | DontEnum);
630     putDirect(vm, vm.propertyNames->length, jsNumber(2), ReadOnly | DontEnum);
631     reifyStaticProperties(vm, JSTestObjConstructorTableValues, *this);
632 }
633
634 template<> const ClassInfo JSTestObjConstructor::s_info = { "TestObject", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestObjConstructor) };
635
636 /* Hash table for prototype */
637
638 static const HashTableValue JSTestObjPrototypeTableValues[] =
639 {
640     { "constructor", DontEnum, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConstructor) } },
641     { "readOnlyLongAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
642     { "readOnlyStringAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
643     { "readOnlyTestObjAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
644     { "enumAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnumAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnumAttr) } },
645     { "byteAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjByteAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjByteAttr) } },
646     { "octetAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOctetAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOctetAttr) } },
647     { "shortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjShortAttr) } },
648     { "clampedShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjClampedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjClampedShortAttr) } },
649     { "enforceRangeShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnforceRangeShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnforceRangeShortAttr) } },
650     { "unsignedShortAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedShortAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedShortAttr) } },
651     { "longAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongAttr) } },
652     { "longLongAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLongLongAttr) } },
653     { "unsignedLongLongAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjUnsignedLongLongAttr) } },
654     { "stringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttr) } },
655     { "testObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestObjAttr) } },
656     { "lenientTestObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjLenientTestObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjLenientTestObjAttr) } },
657     { "stringAttrTreatingNullAsEmptyString", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrTreatingNullAsEmptyString), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrTreatingNullAsEmptyString) } },
658     { "XMLObjAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjXMLObjAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjXMLObjAttr) } },
659     { "create", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCreate), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCreate) } },
660     { "readOnlySymbolAttr", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlySymbolAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
661     { "reflectedStringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) } },
662     { "reflectedIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedIntegralAttr) } },
663     { "reflectedUnsignedIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedUnsignedIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedUnsignedIntegralAttr) } },
664     { "reflectedBooleanAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedBooleanAttr) } },
665     { "reflectedURLAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedURLAttr) } },
666     { "reflectedStringAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedStringAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedStringAttr) } },
667     { "reflectedCustomIntegralAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomIntegralAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomIntegralAttr) } },
668     { "reflectedCustomBooleanAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomBooleanAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomBooleanAttr) } },
669     { "reflectedCustomURLAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReflectedCustomURLAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReflectedCustomURLAttr) } },
670 #if ENABLE(TEST_FEATURE)
671     { "enabledAtRuntimeAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjEnabledAtRuntimeAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjEnabledAtRuntimeAttribute) } },
672 #else
673     { 0, 0, NoIntrinsic, { 0, 0 } },
674 #endif
675     { "typedArrayAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTypedArrayAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTypedArrayAttr) } },
676     { "attrWithGetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterException) } },
677     { "attrWithGetterExceptionWithMessage", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithGetterExceptionWithMessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithGetterExceptionWithMessage) } },
678     { "attrWithSetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterException) } },
679     { "attrWithSetterExceptionWithMessage", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttrWithSetterExceptionWithMessage), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttrWithSetterExceptionWithMessage) } },
680     { "stringAttrWithGetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithGetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithGetterException) } },
681     { "stringAttrWithSetterException", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStringAttrWithSetterException), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStringAttrWithSetterException) } },
682     { "strictTypeCheckingAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictTypeCheckingAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictTypeCheckingAttribute) } },
683     { "customAttr", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCustomAttr) } },
684 #if ENABLE(Condition4)
685     { "jsBuiltinAttribute", Accessor | Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinAttributeCodeGenerator), (intptr_t) (setTestObjJsBuiltinAttributeCodeGenerator) } },
686 #else
687     { 0, 0, NoIntrinsic, { 0, 0 } },
688 #endif
689 #if ENABLE(Condition4)
690     { "jsBuiltinReadOnlyAttribute", ReadOnly | Accessor | Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinReadOnlyAttributeCodeGenerator), (intptr_t) (0) } },
691 #else
692     { 0, 0, NoIntrinsic, { 0, 0 } },
693 #endif
694     { "onfoo", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOnfoo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOnfoo) } },
695     { "onwebkitfoo", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjOnwebkitfoo), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjOnwebkitfoo) } },
696     { "withScriptStateAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttribute) } },
697     { "withCallWithAndSetterCallWithAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithCallWithAndSetterCallWithAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithCallWithAndSetterCallWithAttribute) } },
698     { "withScriptExecutionContextAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttribute) } },
699     { "withScriptStateAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptStateAttributeRaises) } },
700     { "withScriptExecutionContextAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAttributeRaises) } },
701     { "withScriptExecutionContextAndScriptStateAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttribute) } },
702     { "withScriptExecutionContextAndScriptStateAttributeRaises", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises) } },
703     { "withScriptExecutionContextAndScriptStateWithSpacesAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute) } },
704     { "withScriptArgumentsAndCallStackAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) } },
705 #if ENABLE(Condition1)
706     { "conditionalAttr1", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) } },
707 #else
708     { 0, 0, NoIntrinsic, { 0, 0 } },
709 #endif
710 #if ENABLE(Condition1) && ENABLE(Condition2)
711     { "conditionalAttr2", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) } },
712 #else
713     { 0, 0, NoIntrinsic, { 0, 0 } },
714 #endif
715 #if ENABLE(Condition1) || ENABLE(Condition2)
716     { "conditionalAttr3", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) } },
717 #else
718     { 0, 0, NoIntrinsic, { 0, 0 } },
719 #endif
720     { "cachedAttribute1", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
721     { "cachedAttribute2", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
722     { "anyAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAnyAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAnyAttribute) } },
723     { "contentDocument", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjContentDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
724     { "mutablePoint", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjMutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjMutablePoint) } },
725     { "immutablePoint", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjImmutablePoint), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjImmutablePoint) } },
726     { "strawberry", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrawberry), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrawberry) } },
727     { "strictFloat", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjStrictFloat), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjStrictFloat) } },
728     { "description", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjDescription), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
729     { "id", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjId), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjId) } },
730     { "hash", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjHash), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
731     { "replaceableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReplaceableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjReplaceableAttribute) } },
732     { "nullableDoubleAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableDoubleAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
733     { "nullableLongAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
734     { "nullableBooleanAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableBooleanAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
735     { "nullableStringAttribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
736     { "nullableLongSettableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableLongSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableLongSettableAttribute) } },
737     { "nullableStringSettableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringSettableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringSettableAttribute) } },
738     { "nullableStringValue", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjNullableStringValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjNullableStringValue) } },
739     { "attribute", ReadOnly | CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) } },
740     { "attributeWithReservedEnumType", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) } },
741     { "putForwardsAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsAttribute) } },
742     { "putForwardsNullableAttribute", CustomAccessor, NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjPutForwardsNullableAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjPutForwardsNullableAttribute) } },
743 #if ENABLE(TEST_FEATURE)
744     { "enabledAtRuntimeOperation", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionEnabledAtRuntimeOperation), (intptr_t) (1) } },
745 #else
746     { 0, 0, NoIntrinsic, { 0, 0 } },
747 #endif
748     { "voidMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethod), (intptr_t) (0) } },
749     { "voidMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVoidMethodWithArgs), (intptr_t) (3) } },
750     { "byteMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethod), (intptr_t) (0) } },
751     { "byteMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionByteMethodWithArgs), (intptr_t) (3) } },
752     { "octetMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethod), (intptr_t) (0) } },
753     { "octetMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOctetMethodWithArgs), (intptr_t) (3) } },
754     { "longMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethod), (intptr_t) (0) } },
755     { "longMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionLongMethodWithArgs), (intptr_t) (3) } },
756     { "objMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethod), (intptr_t) (0) } },
757     { "objMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionObjMethodWithArgs), (intptr_t) (3) } },
758     { "methodWithArgTreatingNullAsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithArgTreatingNullAsEmptyString), (intptr_t) (1) } },
759     { "nullableStringMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionNullableStringMethod), (intptr_t) (0) } },
760     { "nullableStringSpecialMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionNullableStringSpecialMethod), (intptr_t) (1) } },
761     { "methodWithSequenceArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithSequenceArg), (intptr_t) (1) } },
762     { "methodReturningSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodReturningSequence), (intptr_t) (1) } },
763     { "methodWithEnumArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithEnumArg), (intptr_t) (1) } },
764     { "methodWithOptionalEnumArgAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalEnumArgAndDefaultValue), (intptr_t) (0) } },
765     { "methodThatRequiresAllArgsAndThrows", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodThatRequiresAllArgsAndThrows), (intptr_t) (2) } },
766     { "serializedValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionSerializedValue), (intptr_t) (1) } },
767     { "optionsObject", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOptionsObject), (intptr_t) (1) } },
768     { "methodWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithException), (intptr_t) (0) } },
769     { "methodWithExceptionWithMessage", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithExceptionWithMessage), (intptr_t) (0) } },
770     { "customMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethod), (intptr_t) (0) } },
771     { "customMethodWithArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionCustomMethodWithArgs), (intptr_t) (3) } },
772 #if ENABLE(Condition3)
773     { "jsBuiltinMethod", JSC::Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinMethodCodeGenerator), (intptr_t) (0) } },
774 #else
775     { 0, 0, NoIntrinsic, { 0, 0 } },
776 #endif
777 #if ENABLE(Condition3)
778     { "jsBuiltinMethodWithArgs", JSC::Builtin, NoIntrinsic, { (intptr_t)static_cast<BuiltinGenerator>(testObjJsBuiltinMethodWithArgsCodeGenerator), (intptr_t) (3) } },
779 #else
780     { 0, 0, NoIntrinsic, { 0, 0 } },
781 #endif
782     { "addEventListener", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAddEventListener), (intptr_t) (2) } },
783     { "removeEventListener", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionRemoveEventListener), (intptr_t) (2) } },
784     { "withScriptStateVoid", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoid), (intptr_t) (0) } },
785     { "withScriptStateObj", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObj), (intptr_t) (0) } },
786     { "withScriptStateVoidException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateVoidException), (intptr_t) (0) } },
787     { "withScriptStateObjException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptStateObjException), (intptr_t) (0) } },
788     { "withScriptExecutionContext", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContext), (intptr_t) (0) } },
789     { "withScriptExecutionContextAndScriptState", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptState), (intptr_t) (0) } },
790     { "withScriptExecutionContextAndScriptStateObjException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateObjException), (intptr_t) (0) } },
791     { "withScriptExecutionContextAndScriptStateWithSpaces", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptExecutionContextAndScriptStateWithSpaces), (intptr_t) (0) } },
792     { "withScriptArgumentsAndCallStack", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithScriptArgumentsAndCallStack), (intptr_t) (0) } },
793     { "withDocumentArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionWithDocumentArgument), (intptr_t) (0) } },
794     { "methodWithOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArg), (intptr_t) (0) } },
795     { "methodWithOptionalArgAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArgAndDefaultValue), (intptr_t) (0) } },
796     { "methodWithNonOptionalArgAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndOptionalArg), (intptr_t) (1) } },
797     { "methodWithNonOptionalArgAndTwoOptionalArgs", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonOptionalArgAndTwoOptionalArgs), (intptr_t) (1) } },
798     { "methodWithOptionalString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalString), (intptr_t) (0) } },
799     { "methodWithOptionalAtomicString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicString), (intptr_t) (0) } },
800     { "methodWithOptionalStringAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue), (intptr_t) (0) } },
801     { "methodWithOptionalAtomicStringAndDefaultValue", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue), (intptr_t) (0) } },
802     { "methodWithOptionalStringIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull), (intptr_t) (0) } },
803     { "methodWithOptionalStringIsUndefined", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined), (intptr_t) (0) } },
804     { "methodWithOptionalAtomicStringIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull), (intptr_t) (0) } },
805     { "methodWithOptionalStringIsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString), (intptr_t) (0) } },
806     { "methodWithOptionalAtomicStringIsEmptyString", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString), (intptr_t) (0) } },
807     { "methodWithOptionalDoubleIsNaN", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN), (intptr_t) (0) } },
808     { "methodWithOptionalFloatIsNaN", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN), (intptr_t) (0) } },
809     { "methodWithOptionalSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalSequence), (intptr_t) (0) } },
810     { "methodWithOptionalLongLong", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalLongLong), (intptr_t) (0) } },
811     { "methodWithOptionalLongLongIsZero", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalLongLongIsZero), (intptr_t) (0) } },
812     { "methodWithOptionalUnsignedLongLong", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLong), (intptr_t) (0) } },
813     { "methodWithOptionalUnsignedLongLongIsZero", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUnsignedLongLongIsZero), (intptr_t) (0) } },
814     { "methodWithOptionalArray", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArray), (intptr_t) (0) } },
815     { "methodWithOptionalArrayIsEmpty", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalArrayIsEmpty), (intptr_t) (0) } },
816     { "methodWithOptionalBoolean", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalBoolean), (intptr_t) (0) } },
817     { "methodWithOptionalBooleanIsFalse", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalBooleanIsFalse), (intptr_t) (0) } },
818     { "methodWithOptionalAny", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAny), (intptr_t) (0) } },
819     { "methodWithOptionalNullableWrapper", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapper), (intptr_t) (0) } },
820     { "methodWithOptionalNullableWrapperIsNull", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalNullableWrapperIsNull), (intptr_t) (0) } },
821     { "methodWithCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackArg), (intptr_t) (1) } },
822     { "methodWithNonCallbackArgAndCallbackArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackArg), (intptr_t) (2) } },
823     { "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) } },
824     { "methodWithCallbackFunctionArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackFunctionArg), (intptr_t) (1) } },
825     { "methodWithNonCallbackArgAndCallbackFunctionArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNonCallbackArgAndCallbackFunctionArg), (intptr_t) (2) } },
826     { "methodWithCallbackFunctionAndOptionalArg", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackFunctionAndOptionalArg), (intptr_t) (0) } },
827 #if ENABLE(Condition1)
828     { "conditionalMethod1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) } },
829 #else
830     { 0, 0, NoIntrinsic, { 0, 0 } },
831 #endif
832 #if ENABLE(Condition1) && ENABLE(Condition2)
833     { "conditionalMethod2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) } },
834 #else
835     { 0, 0, NoIntrinsic, { 0, 0 } },
836 #endif
837 #if ENABLE(Condition1) || ENABLE(Condition2)
838     { "conditionalMethod3", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) } },
839 #else
840     { 0, 0, NoIntrinsic, { 0, 0 } },
841 #endif
842     { "overloadedMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) } },
843     { "overloadedMethodWithOptionalParameter", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethodWithOptionalParameter), (intptr_t) (1) } },
844     { "classMethodWithClamp", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) } },
845     { "classMethodWithEnforceRange", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithEnforceRange), (intptr_t) (2) } },
846     { "methodWithUnsignedLongSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithUnsignedLongSequence), (intptr_t) (1) } },
847     { "stringArrayFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStringArrayFunction), (intptr_t) (1) } },
848     { "domStringListFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionDomStringListFunction), (intptr_t) (1) } },
849     { "methodWithAndWithoutNullableSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence), (intptr_t) (2) } },
850     { "methodWithAndWithoutNullableSequence2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithAndWithoutNullableSequence2), (intptr_t) (2) } },
851     { "getSVGDocument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionGetSVGDocument), (intptr_t) (0) } },
852     { "convert1", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert1), (intptr_t) (1) } },
853     { "convert2", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert2), (intptr_t) (1) } },
854     { "convert3", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert3), (intptr_t) (1) } },
855     { "convert4", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConvert4), (intptr_t) (1) } },
856     { "mutablePointFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMutablePointFunction), (intptr_t) (0) } },
857     { "immutablePointFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionImmutablePointFunction), (intptr_t) (0) } },
858     { "orange", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOrange), (intptr_t) (0) } },
859     { "strictFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunction), (intptr_t) (3) } },
860     { "strictFunctionWithSequence", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithSequence), (intptr_t) (2) } },
861     { "strictFunctionWithArray", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionStrictFunctionWithArray), (intptr_t) (2) } },
862     { "variadicStringMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicStringMethod), (intptr_t) (1) } },
863     { "variadicDoubleMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (1) } },
864     { "variadicNodeMethod", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (1) } },
865     { "any", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) } },
866     { "testPromiseFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunction), (intptr_t) (0) } },
867     { "testPromiseFunctionWithFloatArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument), (intptr_t) (1) } },
868     { "testPromiseFunctionWithException", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithException), (intptr_t) (0) } },
869     { "testPromiseFunctionWithOptionalIntArgument", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument), (intptr_t) (0) } },
870     { "testPromiseOverloadedFunction", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionTestPromiseOverloadedFunction), (intptr_t) (1) } },
871     { "methodWithNeedsLifecycleProcessingStack", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithNeedsLifecycleProcessingStack), (intptr_t) (0) } },
872     { "entries", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionEntries), (intptr_t) (0) } },
873     { "keys", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionKeys), (intptr_t) (0) } },
874     { "values", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionValues), (intptr_t) (0) } },
875     { "forEach", JSC::Function, NoIntrinsic, { (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionForEach), (intptr_t) (1) } },
876 #if ENABLE(Condition1)
877     { "CONDITIONAL_CONST", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
878 #else
879     { 0, 0, NoIntrinsic, { 0, 0 } },
880 #endif
881     { "CONST_VALUE_0", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
882     { "CONST_VALUE_1", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(1) } },
883     { "CONST_VALUE_2", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(2) } },
884     { "CONST_VALUE_4", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(4) } },
885     { "CONST_VALUE_8", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(8) } },
886     { "CONST_VALUE_9", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(-1) } },
887     { "CONST_VALUE_11", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0xffffffff) } },
888     { "CONST_VALUE_12", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x01) } },
889     { "CONST_VALUE_13", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0X20) } },
890     { "CONST_VALUE_14", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0x1abc) } },
891     { "CONST_JAVASCRIPT", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(15) } },
892     { "readonly", DontDelete | ReadOnly | ConstantInteger, NoIntrinsic, { (long long)(0) } },
893 };
894
895 const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
896
897 void JSTestObjPrototype::finishCreation(VM& vm)
898 {
899     Base::finishCreation(vm);
900     reifyStaticProperties(vm, JSTestObjPrototypeTableValues, *this);
901 #if ENABLE(TEST_FEATURE)
902     if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
903         Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>("enabledAtRuntimeOperation"), strlen("enabledAtRuntimeOperation"));
904         removeDirect(vm, propertyName);
905     }
906 #endif
907 #if ENABLE(TEST_FEATURE)
908     if (!RuntimeEnabledFeatures::sharedFeatures().testFeatureEnabled()) {
909         Identifier propertyName = Identifier::fromString(&vm, reinterpret_cast<const LChar*>("enabledAtRuntimeAttribute"), strlen("enabledAtRuntimeAttribute"));
910         removeDirect(vm, propertyName);
911     }
912 #endif
913     JSVMClientData& clientData = *static_cast<JSVMClientData*>(vm.clientData);
914     putDirect(vm, clientData.builtinNames().privateMethodPrivateName(), JSFunction::create(vm, globalObject(), 0, String(), jsTestObjPrototypeFunctionPrivateMethod), ReadOnly | DontEnum);
915     putDirect(vm, vm.propertyNames->iteratorSymbol, JSFunction::create(vm, globalObject(), 0, ASCIILiteral("[Symbol.Iterator]"), jsTestObjPrototypeFunctionSymbolIterator), ReadOnly | DontEnum);
916 }
917
918 const ClassInfo JSTestObj::s_info = { "TestObject", &Base::s_info, &JSTestObjTable, CREATE_METHOD_TABLE(JSTestObj) };
919
920 JSTestObj::JSTestObj(Structure* structure, JSDOMGlobalObject& globalObject, Ref<TestObj>&& impl)
921     : JSDOMWrapper<TestObj>(structure, globalObject, WTFMove(impl))
922 {
923 }
924
925 JSObject* JSTestObj::createPrototype(VM& vm, JSGlobalObject* globalObject)
926 {
927     return JSTestObjPrototype::create(vm, globalObject, JSTestObjPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
928 }
929
930 JSObject* JSTestObj::prototype(VM& vm, JSGlobalObject* globalObject)
931 {
932     return getDOMPrototype<JSTestObj>(vm, globalObject);
933 }
934
935 void JSTestObj::destroy(JSC::JSCell* cell)
936 {
937     JSTestObj* thisObject = static_cast<JSTestObj*>(cell);
938     thisObject->JSTestObj::~JSTestObj();
939 }
940
941 bool JSTestObj::getOwnPropertySlot(JSObject* object, ExecState* state, PropertyName propertyName, PropertySlot& slot)
942 {
943     auto* thisObject = jsCast<JSTestObj*>(object);
944     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
945     Optional<uint32_t> optionalIndex = parseIndex(propertyName);
946     if (optionalIndex) {
947         unsigned index = optionalIndex.value();
948         unsigned attributes = DontDelete | ReadOnly;
949         slot.setValue(thisObject, attributes, jsStringOrUndefined(state, thisObject->wrapped().item(index)));
950         return true;
951     }
952     if (getStaticPropertySlot<JSTestObj, Base>(state, JSTestObjTable, thisObject, propertyName, slot))
953         return true;
954     return false;
955 }
956
957 bool JSTestObj::getOwnPropertySlotByIndex(JSObject* object, ExecState* state, unsigned index, PropertySlot& slot)
958 {
959     auto* thisObject = jsCast<JSTestObj*>(object);
960     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
961     if (LIKELY(index <= MAX_ARRAY_INDEX)) {
962         unsigned attributes = DontDelete | ReadOnly;
963         slot.setValue(thisObject, attributes, jsStringOrUndefined(state, thisObject->wrapped().item(index)));
964         return true;
965     }
966     return Base::getOwnPropertySlotByIndex(thisObject, state, index, slot);
967 }
968
969 EncodedJSValue jsTestObjReadOnlyLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
970 {
971     UNUSED_PARAM(state);
972     UNUSED_PARAM(thisValue);
973     JSValue decodedThisValue = JSValue::decode(thisValue);
974     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
975     if (UNLIKELY(!castedThis)) {
976         return throwGetterTypeError(*state, "TestObj", "readOnlyLongAttr");
977     }
978     auto& impl = castedThis->wrapped();
979     JSValue result = jsNumber(impl.readOnlyLongAttr());
980     return JSValue::encode(result);
981 }
982
983
984 EncodedJSValue jsTestObjReadOnlyStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
985 {
986     UNUSED_PARAM(state);
987     UNUSED_PARAM(thisValue);
988     JSValue decodedThisValue = JSValue::decode(thisValue);
989     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
990     if (UNLIKELY(!castedThis)) {
991         return throwGetterTypeError(*state, "TestObj", "readOnlyStringAttr");
992     }
993     auto& impl = castedThis->wrapped();
994     JSValue result = jsStringWithCache(state, impl.readOnlyStringAttr());
995     return JSValue::encode(result);
996 }
997
998
999 EncodedJSValue jsTestObjReadOnlyTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1000 {
1001     UNUSED_PARAM(state);
1002     UNUSED_PARAM(thisValue);
1003     JSValue decodedThisValue = JSValue::decode(thisValue);
1004     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1005     if (UNLIKELY(!castedThis)) {
1006         return throwGetterTypeError(*state, "TestObj", "readOnlyTestObjAttr");
1007     }
1008     auto& impl = castedThis->wrapped();
1009     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.readOnlyTestObjAttr()));
1010     return JSValue::encode(result);
1011 }
1012
1013
1014 EncodedJSValue jsTestObjConstructorStaticReadOnlyLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1015 {
1016     UNUSED_PARAM(state);
1017     UNUSED_PARAM(thisValue);
1018     JSValue result = jsNumber(TestObj::staticReadOnlyLongAttr());
1019     return JSValue::encode(result);
1020 }
1021
1022
1023 EncodedJSValue jsTestObjConstructorStaticStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1024 {
1025     UNUSED_PARAM(state);
1026     UNUSED_PARAM(thisValue);
1027     JSValue result = jsStringWithCache(state, TestObj::staticStringAttr());
1028     return JSValue::encode(result);
1029 }
1030
1031
1032 EncodedJSValue jsTestObjConstructorTestSubObj(ExecState* state, EncodedJSValue thisValue, PropertyName)
1033 {
1034     UNUSED_PARAM(state);
1035     UNUSED_PARAM(thisValue);
1036     JSValue decodedThisValue = JSValue::decode(thisValue);
1037     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1038     if (UNLIKELY(!castedThis)) {
1039         return throwGetterTypeError(*state, "TestObj", "TestSubObj");
1040     }
1041     return JSValue::encode(JSTestSubObj::getConstructor(state->vm(), castedThis->globalObject()));
1042 }
1043
1044
1045 EncodedJSValue jsTestObjTestSubObjEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
1046 {
1047     UNUSED_PARAM(state);
1048     UNUSED_PARAM(thisValue);
1049     JSValue decodedThisValue = JSValue::decode(thisValue);
1050     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1051     if (UNLIKELY(!castedThis)) {
1052         return throwGetterTypeError(*state, "TestObj", "TestSubObjEnabledBySetting");
1053     }
1054     if (UNLIKELY(!castedThis->wrapped().frame()))
1055         return JSValue::encode(jsUndefined());
1056     Settings& settings = castedThis->wrapped().frame()->settings();
1057     if (!settings.testSettingEnabled())
1058         return JSValue::encode(jsUndefined());
1059     return JSValue::encode(JSTestSubObj::getConstructor(state->vm(), castedThis->globalObject()));
1060 }
1061
1062
1063 EncodedJSValue jsTestObjEnumAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1064 {
1065     UNUSED_PARAM(state);
1066     UNUSED_PARAM(thisValue);
1067     JSValue decodedThisValue = JSValue::decode(thisValue);
1068     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1069     if (UNLIKELY(!castedThis)) {
1070         return throwGetterTypeError(*state, "TestObj", "enumAttr");
1071     }
1072     auto& impl = castedThis->wrapped();
1073     JSValue result = jsStringWithCache(state, impl.enumAttr());
1074     return JSValue::encode(result);
1075 }
1076
1077
1078 EncodedJSValue jsTestObjByteAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1079 {
1080     UNUSED_PARAM(state);
1081     UNUSED_PARAM(thisValue);
1082     JSValue decodedThisValue = JSValue::decode(thisValue);
1083     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1084     if (UNLIKELY(!castedThis)) {
1085         return throwGetterTypeError(*state, "TestObj", "byteAttr");
1086     }
1087     auto& impl = castedThis->wrapped();
1088     JSValue result = jsNumber(impl.byteAttr());
1089     return JSValue::encode(result);
1090 }
1091
1092
1093 EncodedJSValue jsTestObjOctetAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1094 {
1095     UNUSED_PARAM(state);
1096     UNUSED_PARAM(thisValue);
1097     JSValue decodedThisValue = JSValue::decode(thisValue);
1098     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1099     if (UNLIKELY(!castedThis)) {
1100         return throwGetterTypeError(*state, "TestObj", "octetAttr");
1101     }
1102     auto& impl = castedThis->wrapped();
1103     JSValue result = jsNumber(impl.octetAttr());
1104     return JSValue::encode(result);
1105 }
1106
1107
1108 EncodedJSValue jsTestObjShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1109 {
1110     UNUSED_PARAM(state);
1111     UNUSED_PARAM(thisValue);
1112     JSValue decodedThisValue = JSValue::decode(thisValue);
1113     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1114     if (UNLIKELY(!castedThis)) {
1115         return throwGetterTypeError(*state, "TestObj", "shortAttr");
1116     }
1117     auto& impl = castedThis->wrapped();
1118     JSValue result = jsNumber(impl.shortAttr());
1119     return JSValue::encode(result);
1120 }
1121
1122
1123 EncodedJSValue jsTestObjClampedShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1124 {
1125     UNUSED_PARAM(state);
1126     UNUSED_PARAM(thisValue);
1127     JSValue decodedThisValue = JSValue::decode(thisValue);
1128     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1129     if (UNLIKELY(!castedThis)) {
1130         return throwGetterTypeError(*state, "TestObj", "clampedShortAttr");
1131     }
1132     auto& impl = castedThis->wrapped();
1133     JSValue result = jsNumber(impl.clampedShortAttr());
1134     return JSValue::encode(result);
1135 }
1136
1137
1138 EncodedJSValue jsTestObjEnforceRangeShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1139 {
1140     UNUSED_PARAM(state);
1141     UNUSED_PARAM(thisValue);
1142     JSValue decodedThisValue = JSValue::decode(thisValue);
1143     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1144     if (UNLIKELY(!castedThis)) {
1145         return throwGetterTypeError(*state, "TestObj", "enforceRangeShortAttr");
1146     }
1147     auto& impl = castedThis->wrapped();
1148     JSValue result = jsNumber(impl.enforceRangeShortAttr());
1149     return JSValue::encode(result);
1150 }
1151
1152
1153 EncodedJSValue jsTestObjUnsignedShortAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1154 {
1155     UNUSED_PARAM(state);
1156     UNUSED_PARAM(thisValue);
1157     JSValue decodedThisValue = JSValue::decode(thisValue);
1158     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1159     if (UNLIKELY(!castedThis)) {
1160         return throwGetterTypeError(*state, "TestObj", "unsignedShortAttr");
1161     }
1162     auto& impl = castedThis->wrapped();
1163     JSValue result = jsNumber(impl.unsignedShortAttr());
1164     return JSValue::encode(result);
1165 }
1166
1167
1168 EncodedJSValue jsTestObjLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1169 {
1170     UNUSED_PARAM(state);
1171     UNUSED_PARAM(thisValue);
1172     JSValue decodedThisValue = JSValue::decode(thisValue);
1173     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1174     if (UNLIKELY(!castedThis)) {
1175         return throwGetterTypeError(*state, "TestObj", "longAttr");
1176     }
1177     auto& impl = castedThis->wrapped();
1178     JSValue result = jsNumber(impl.longAttr());
1179     return JSValue::encode(result);
1180 }
1181
1182
1183 EncodedJSValue jsTestObjLongLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1184 {
1185     UNUSED_PARAM(state);
1186     UNUSED_PARAM(thisValue);
1187     JSValue decodedThisValue = JSValue::decode(thisValue);
1188     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1189     if (UNLIKELY(!castedThis)) {
1190         return throwGetterTypeError(*state, "TestObj", "longLongAttr");
1191     }
1192     auto& impl = castedThis->wrapped();
1193     JSValue result = jsNumber(impl.longLongAttr());
1194     return JSValue::encode(result);
1195 }
1196
1197
1198 EncodedJSValue jsTestObjUnsignedLongLongAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1199 {
1200     UNUSED_PARAM(state);
1201     UNUSED_PARAM(thisValue);
1202     JSValue decodedThisValue = JSValue::decode(thisValue);
1203     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1204     if (UNLIKELY(!castedThis)) {
1205         return throwGetterTypeError(*state, "TestObj", "unsignedLongLongAttr");
1206     }
1207     auto& impl = castedThis->wrapped();
1208     JSValue result = jsNumber(impl.unsignedLongLongAttr());
1209     return JSValue::encode(result);
1210 }
1211
1212
1213 EncodedJSValue jsTestObjStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1214 {
1215     UNUSED_PARAM(state);
1216     UNUSED_PARAM(thisValue);
1217     JSValue decodedThisValue = JSValue::decode(thisValue);
1218     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1219     if (UNLIKELY(!castedThis)) {
1220         return throwGetterTypeError(*state, "TestObj", "stringAttr");
1221     }
1222     auto& impl = castedThis->wrapped();
1223     JSValue result = jsStringWithCache(state, impl.stringAttr());
1224     return JSValue::encode(result);
1225 }
1226
1227
1228 EncodedJSValue jsTestObjTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1229 {
1230     UNUSED_PARAM(state);
1231     UNUSED_PARAM(thisValue);
1232     JSValue decodedThisValue = JSValue::decode(thisValue);
1233     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1234     if (UNLIKELY(!castedThis)) {
1235         return throwGetterTypeError(*state, "TestObj", "testObjAttr");
1236     }
1237     auto& impl = castedThis->wrapped();
1238     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.testObjAttr()));
1239     return JSValue::encode(result);
1240 }
1241
1242
1243 EncodedJSValue jsTestObjLenientTestObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1244 {
1245     UNUSED_PARAM(state);
1246     UNUSED_PARAM(thisValue);
1247     JSValue decodedThisValue = JSValue::decode(thisValue);
1248     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1249     if (UNLIKELY(!castedThis)) {
1250         return JSValue::encode(jsUndefined());
1251     }
1252     auto& impl = castedThis->wrapped();
1253     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.lenientTestObjAttr()));
1254     return JSValue::encode(result);
1255 }
1256
1257
1258 EncodedJSValue jsTestObjUnforgeableAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1259 {
1260     UNUSED_PARAM(state);
1261     UNUSED_PARAM(thisValue);
1262     JSValue decodedThisValue = JSValue::decode(thisValue);
1263     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1264     if (UNLIKELY(!castedThis)) {
1265         return throwGetterTypeError(*state, "TestObj", "unforgeableAttr");
1266     }
1267     auto& impl = castedThis->wrapped();
1268     JSValue result = jsStringWithCache(state, impl.unforgeableAttr());
1269     return JSValue::encode(result);
1270 }
1271
1272
1273 EncodedJSValue jsTestObjStringAttrTreatingNullAsEmptyString(ExecState* state, EncodedJSValue thisValue, PropertyName)
1274 {
1275     UNUSED_PARAM(state);
1276     UNUSED_PARAM(thisValue);
1277     JSValue decodedThisValue = JSValue::decode(thisValue);
1278     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1279     if (UNLIKELY(!castedThis)) {
1280         return throwGetterTypeError(*state, "TestObj", "stringAttrTreatingNullAsEmptyString");
1281     }
1282     auto& impl = castedThis->wrapped();
1283     JSValue result = jsStringWithCache(state, impl.stringAttrTreatingNullAsEmptyString());
1284     return JSValue::encode(result);
1285 }
1286
1287
1288 EncodedJSValue jsTestObjXMLObjAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1289 {
1290     UNUSED_PARAM(state);
1291     UNUSED_PARAM(thisValue);
1292     JSValue decodedThisValue = JSValue::decode(thisValue);
1293     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1294     if (UNLIKELY(!castedThis)) {
1295         return throwGetterTypeError(*state, "TestObj", "XMLObjAttr");
1296     }
1297     auto& impl = castedThis->wrapped();
1298     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.xmlObjAttr()));
1299     return JSValue::encode(result);
1300 }
1301
1302
1303 EncodedJSValue jsTestObjCreate(ExecState* state, EncodedJSValue thisValue, PropertyName)
1304 {
1305     UNUSED_PARAM(state);
1306     UNUSED_PARAM(thisValue);
1307     JSValue decodedThisValue = JSValue::decode(thisValue);
1308     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1309     if (UNLIKELY(!castedThis)) {
1310         return throwGetterTypeError(*state, "TestObj", "create");
1311     }
1312     auto& impl = castedThis->wrapped();
1313     JSValue result = jsBoolean(impl.isCreate());
1314     return JSValue::encode(result);
1315 }
1316
1317
1318 EncodedJSValue jsTestObjReadOnlySymbolAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1319 {
1320     UNUSED_PARAM(state);
1321     UNUSED_PARAM(thisValue);
1322     JSValue decodedThisValue = JSValue::decode(thisValue);
1323     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1324     if (UNLIKELY(!castedThis)) {
1325         return throwGetterTypeError(*state, "TestObj", "readOnlySymbolAttr");
1326     }
1327     auto& impl = castedThis->wrapped();
1328     JSValue result = Symbol::create(state->vm(), *(impl.readOnlySymbolAttr()).uid());
1329     return JSValue::encode(result);
1330 }
1331
1332
1333 EncodedJSValue jsTestObjConstructorStaticReadOnlySymbolAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1334 {
1335     UNUSED_PARAM(state);
1336     UNUSED_PARAM(thisValue);
1337     JSValue result = Symbol::create(state->vm(), *(TestObj::staticReadOnlySymbolAttr()).uid());
1338     return JSValue::encode(result);
1339 }
1340
1341
1342 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1343 {
1344     UNUSED_PARAM(state);
1345     UNUSED_PARAM(thisValue);
1346     JSValue decodedThisValue = JSValue::decode(thisValue);
1347     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1348     if (UNLIKELY(!castedThis)) {
1349         return throwGetterTypeError(*state, "TestObj", "reflectedStringAttr");
1350     }
1351     auto& impl = castedThis->wrapped();
1352     JSValue result = jsStringWithCache(state, impl.fastGetAttribute(WebCore::HTMLNames::reflectedstringattrAttr));
1353     return JSValue::encode(result);
1354 }
1355
1356
1357 EncodedJSValue jsTestObjReflectedIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1358 {
1359     UNUSED_PARAM(state);
1360     UNUSED_PARAM(thisValue);
1361     JSValue decodedThisValue = JSValue::decode(thisValue);
1362     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1363     if (UNLIKELY(!castedThis)) {
1364         return throwGetterTypeError(*state, "TestObj", "reflectedIntegralAttr");
1365     }
1366     auto& impl = castedThis->wrapped();
1367     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr));
1368     return JSValue::encode(result);
1369 }
1370
1371
1372 EncodedJSValue jsTestObjReflectedUnsignedIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1373 {
1374     UNUSED_PARAM(state);
1375     UNUSED_PARAM(thisValue);
1376     JSValue decodedThisValue = JSValue::decode(thisValue);
1377     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1378     if (UNLIKELY(!castedThis)) {
1379         return throwGetterTypeError(*state, "TestObj", "reflectedUnsignedIntegralAttr");
1380     }
1381     auto& impl = castedThis->wrapped();
1382     JSValue result = jsNumber(std::max(0, impl.getIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr)));
1383     return JSValue::encode(result);
1384 }
1385
1386
1387 EncodedJSValue jsTestObjReflectedBooleanAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1388 {
1389     UNUSED_PARAM(state);
1390     UNUSED_PARAM(thisValue);
1391     JSValue decodedThisValue = JSValue::decode(thisValue);
1392     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1393     if (UNLIKELY(!castedThis)) {
1394         return throwGetterTypeError(*state, "TestObj", "reflectedBooleanAttr");
1395     }
1396     auto& impl = castedThis->wrapped();
1397     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr));
1398     return JSValue::encode(result);
1399 }
1400
1401
1402 EncodedJSValue jsTestObjReflectedURLAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1403 {
1404     UNUSED_PARAM(state);
1405     UNUSED_PARAM(thisValue);
1406     JSValue decodedThisValue = JSValue::decode(thisValue);
1407     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1408     if (UNLIKELY(!castedThis)) {
1409         return throwGetterTypeError(*state, "TestObj", "reflectedURLAttr");
1410     }
1411     auto& impl = castedThis->wrapped();
1412     JSValue result = jsStringWithCache(state, impl.getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr));
1413     return JSValue::encode(result);
1414 }
1415
1416
1417 EncodedJSValue jsTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1418 {
1419     UNUSED_PARAM(state);
1420     UNUSED_PARAM(thisValue);
1421     JSValue decodedThisValue = JSValue::decode(thisValue);
1422     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1423     if (UNLIKELY(!castedThis)) {
1424         return throwGetterTypeError(*state, "TestObj", "reflectedStringAttr");
1425     }
1426     auto& impl = castedThis->wrapped();
1427     JSValue result = jsStringWithCache(state, impl.fastGetAttribute(WebCore::HTMLNames::customContentStringAttrAttr));
1428     return JSValue::encode(result);
1429 }
1430
1431
1432 EncodedJSValue jsTestObjReflectedCustomIntegralAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1433 {
1434     UNUSED_PARAM(state);
1435     UNUSED_PARAM(thisValue);
1436     JSValue decodedThisValue = JSValue::decode(thisValue);
1437     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1438     if (UNLIKELY(!castedThis)) {
1439         return throwGetterTypeError(*state, "TestObj", "reflectedCustomIntegralAttr");
1440     }
1441     auto& impl = castedThis->wrapped();
1442     JSValue result = jsNumber(impl.getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr));
1443     return JSValue::encode(result);
1444 }
1445
1446
1447 EncodedJSValue jsTestObjReflectedCustomBooleanAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1448 {
1449     UNUSED_PARAM(state);
1450     UNUSED_PARAM(thisValue);
1451     JSValue decodedThisValue = JSValue::decode(thisValue);
1452     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1453     if (UNLIKELY(!castedThis)) {
1454         return throwGetterTypeError(*state, "TestObj", "reflectedCustomBooleanAttr");
1455     }
1456     auto& impl = castedThis->wrapped();
1457     JSValue result = jsBoolean(impl.fastHasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr));
1458     return JSValue::encode(result);
1459 }
1460
1461
1462 EncodedJSValue jsTestObjReflectedCustomURLAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1463 {
1464     UNUSED_PARAM(state);
1465     UNUSED_PARAM(thisValue);
1466     JSValue decodedThisValue = JSValue::decode(thisValue);
1467     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1468     if (UNLIKELY(!castedThis)) {
1469         return throwGetterTypeError(*state, "TestObj", "reflectedCustomURLAttr");
1470     }
1471     auto& impl = castedThis->wrapped();
1472     JSValue result = jsStringWithCache(state, impl.getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr));
1473     return JSValue::encode(result);
1474 }
1475
1476
1477 #if ENABLE(TEST_FEATURE)
1478 EncodedJSValue jsTestObjEnabledAtRuntimeAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1479 {
1480     UNUSED_PARAM(state);
1481     UNUSED_PARAM(thisValue);
1482     JSValue decodedThisValue = JSValue::decode(thisValue);
1483     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1484     if (UNLIKELY(!castedThis)) {
1485         return throwGetterTypeError(*state, "TestObj", "enabledAtRuntimeAttribute");
1486     }
1487     auto& impl = castedThis->wrapped();
1488     JSValue result = jsStringWithCache(state, impl.enabledAtRuntimeAttribute());
1489     return JSValue::encode(result);
1490 }
1491
1492 #endif
1493
1494 EncodedJSValue jsTestObjTypedArrayAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1495 {
1496     UNUSED_PARAM(state);
1497     UNUSED_PARAM(thisValue);
1498     JSValue decodedThisValue = JSValue::decode(thisValue);
1499     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1500     if (UNLIKELY(!castedThis)) {
1501         return throwGetterTypeError(*state, "TestObj", "typedArrayAttr");
1502     }
1503     auto& impl = castedThis->wrapped();
1504     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.typedArrayAttr()));
1505     return JSValue::encode(result);
1506 }
1507
1508
1509 EncodedJSValue jsTestObjAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1510 {
1511     UNUSED_PARAM(state);
1512     UNUSED_PARAM(thisValue);
1513     JSValue decodedThisValue = JSValue::decode(thisValue);
1514     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1515     if (UNLIKELY(!castedThis)) {
1516         return throwGetterTypeError(*state, "TestObj", "attrWithGetterException");
1517     }
1518     ExceptionCode ec = 0;
1519     auto& impl = castedThis->wrapped();
1520     JSValue result = jsNumber(impl.attrWithGetterException(ec));
1521     setDOMException(state, ec);
1522     return JSValue::encode(result);
1523 }
1524
1525
1526 EncodedJSValue jsTestObjAttrWithGetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, PropertyName)
1527 {
1528     UNUSED_PARAM(state);
1529     UNUSED_PARAM(thisValue);
1530     JSValue decodedThisValue = JSValue::decode(thisValue);
1531     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1532     if (UNLIKELY(!castedThis)) {
1533         return throwGetterTypeError(*state, "TestObj", "attrWithGetterExceptionWithMessage");
1534     }
1535     ExceptionCodeWithMessage ec;
1536     auto& impl = castedThis->wrapped();
1537     JSValue result = jsNumber(impl.attrWithGetterExceptionWithMessage(ec));
1538     setDOMException(state, ec);
1539     return JSValue::encode(result);
1540 }
1541
1542
1543 EncodedJSValue jsTestObjAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1544 {
1545     UNUSED_PARAM(state);
1546     UNUSED_PARAM(thisValue);
1547     JSValue decodedThisValue = JSValue::decode(thisValue);
1548     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1549     if (UNLIKELY(!castedThis)) {
1550         return throwGetterTypeError(*state, "TestObj", "attrWithSetterException");
1551     }
1552     auto& impl = castedThis->wrapped();
1553     JSValue result = jsNumber(impl.attrWithSetterException());
1554     return JSValue::encode(result);
1555 }
1556
1557
1558 EncodedJSValue jsTestObjAttrWithSetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, PropertyName)
1559 {
1560     UNUSED_PARAM(state);
1561     UNUSED_PARAM(thisValue);
1562     JSValue decodedThisValue = JSValue::decode(thisValue);
1563     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1564     if (UNLIKELY(!castedThis)) {
1565         return throwGetterTypeError(*state, "TestObj", "attrWithSetterExceptionWithMessage");
1566     }
1567     auto& impl = castedThis->wrapped();
1568     JSValue result = jsNumber(impl.attrWithSetterExceptionWithMessage());
1569     return JSValue::encode(result);
1570 }
1571
1572
1573 EncodedJSValue jsTestObjStringAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1574 {
1575     UNUSED_PARAM(state);
1576     UNUSED_PARAM(thisValue);
1577     JSValue decodedThisValue = JSValue::decode(thisValue);
1578     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1579     if (UNLIKELY(!castedThis)) {
1580         return throwGetterTypeError(*state, "TestObj", "stringAttrWithGetterException");
1581     }
1582     ExceptionCode ec = 0;
1583     auto& impl = castedThis->wrapped();
1584     JSValue result = jsStringWithCache(state, impl.stringAttrWithGetterException(ec));
1585     setDOMException(state, ec);
1586     return JSValue::encode(result);
1587 }
1588
1589
1590 EncodedJSValue jsTestObjStringAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, PropertyName)
1591 {
1592     UNUSED_PARAM(state);
1593     UNUSED_PARAM(thisValue);
1594     JSValue decodedThisValue = JSValue::decode(thisValue);
1595     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1596     if (UNLIKELY(!castedThis)) {
1597         return throwGetterTypeError(*state, "TestObj", "stringAttrWithSetterException");
1598     }
1599     auto& impl = castedThis->wrapped();
1600     JSValue result = jsStringWithCache(state, impl.stringAttrWithSetterException());
1601     return JSValue::encode(result);
1602 }
1603
1604
1605 EncodedJSValue jsTestObjStrictTypeCheckingAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1606 {
1607     UNUSED_PARAM(state);
1608     UNUSED_PARAM(thisValue);
1609     JSValue decodedThisValue = JSValue::decode(thisValue);
1610     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1611     if (UNLIKELY(!castedThis)) {
1612         return throwGetterTypeError(*state, "TestObj", "strictTypeCheckingAttribute");
1613     }
1614     auto& impl = castedThis->wrapped();
1615     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.strictTypeCheckingAttribute()));
1616     return JSValue::encode(result);
1617 }
1618
1619
1620 EncodedJSValue jsTestObjCustomAttr(ExecState* state, EncodedJSValue thisValue, PropertyName)
1621 {
1622     UNUSED_PARAM(state);
1623     UNUSED_PARAM(thisValue);
1624     JSValue decodedThisValue = JSValue::decode(thisValue);
1625     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1626     if (UNLIKELY(!castedThis)) {
1627         return throwGetterTypeError(*state, "TestObj", "customAttr");
1628     }
1629     return JSValue::encode(castedThis->customAttr(*state));
1630 }
1631
1632
1633 EncodedJSValue jsTestObjOnfoo(ExecState* state, EncodedJSValue thisValue, PropertyName)
1634 {
1635     UNUSED_PARAM(state);
1636     UNUSED_PARAM(thisValue);
1637     JSValue decodedThisValue = JSValue::decode(thisValue);
1638     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1639     if (UNLIKELY(!castedThis)) {
1640         return throwGetterTypeError(*state, "TestObj", "onfoo");
1641     }
1642     UNUSED_PARAM(state);
1643     return JSValue::encode(eventHandlerAttribute(castedThis->wrapped(), eventNames().fooEvent));
1644 }
1645
1646
1647 EncodedJSValue jsTestObjOnwebkitfoo(ExecState* state, EncodedJSValue thisValue, PropertyName)
1648 {
1649     UNUSED_PARAM(state);
1650     UNUSED_PARAM(thisValue);
1651     JSValue decodedThisValue = JSValue::decode(thisValue);
1652     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1653     if (UNLIKELY(!castedThis)) {
1654         return throwGetterTypeError(*state, "TestObj", "onwebkitfoo");
1655     }
1656     UNUSED_PARAM(state);
1657     return JSValue::encode(eventHandlerAttribute(castedThis->wrapped(), eventNames().fooEvent));
1658 }
1659
1660
1661 EncodedJSValue jsTestObjWithScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1662 {
1663     UNUSED_PARAM(state);
1664     UNUSED_PARAM(thisValue);
1665     JSValue decodedThisValue = JSValue::decode(thisValue);
1666     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1667     if (UNLIKELY(!castedThis)) {
1668         return throwGetterTypeError(*state, "TestObj", "withScriptStateAttribute");
1669     }
1670     auto& impl = castedThis->wrapped();
1671     JSValue result = jsNumber(impl.withScriptStateAttribute(*state));
1672     return JSValue::encode(result);
1673 }
1674
1675
1676 EncodedJSValue jsTestObjWithCallWithAndSetterCallWithAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1677 {
1678     UNUSED_PARAM(state);
1679     UNUSED_PARAM(thisValue);
1680     JSValue decodedThisValue = JSValue::decode(thisValue);
1681     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1682     if (UNLIKELY(!castedThis)) {
1683         return throwGetterTypeError(*state, "TestObj", "withCallWithAndSetterCallWithAttribute");
1684     }
1685     auto& impl = castedThis->wrapped();
1686     JSValue result = jsNumber(impl.withCallWithAndSetterCallWithAttribute(*state));
1687     return JSValue::encode(result);
1688 }
1689
1690
1691 EncodedJSValue jsTestObjWithScriptExecutionContextAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1692 {
1693     UNUSED_PARAM(state);
1694     UNUSED_PARAM(thisValue);
1695     JSValue decodedThisValue = JSValue::decode(thisValue);
1696     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1697     if (UNLIKELY(!castedThis)) {
1698         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAttribute");
1699     }
1700     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
1701     if (!context)
1702         return JSValue::encode(jsUndefined());
1703     auto& impl = castedThis->wrapped();
1704     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttribute(*context)));
1705     return JSValue::encode(result);
1706 }
1707
1708
1709 EncodedJSValue jsTestObjWithScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
1710 {
1711     UNUSED_PARAM(state);
1712     UNUSED_PARAM(thisValue);
1713     JSValue decodedThisValue = JSValue::decode(thisValue);
1714     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1715     if (UNLIKELY(!castedThis)) {
1716         return throwGetterTypeError(*state, "TestObj", "withScriptStateAttributeRaises");
1717     }
1718     ExceptionCode ec = 0;
1719     auto& impl = castedThis->wrapped();
1720     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(*state, ec)));
1721     setDOMException(state, ec);
1722     return JSValue::encode(result);
1723 }
1724
1725
1726 EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
1727 {
1728     UNUSED_PARAM(state);
1729     UNUSED_PARAM(thisValue);
1730     JSValue decodedThisValue = JSValue::decode(thisValue);
1731     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1732     if (UNLIKELY(!castedThis)) {
1733         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAttributeRaises");
1734     }
1735     ExceptionCode ec = 0;
1736     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
1737     if (!context)
1738         return JSValue::encode(jsUndefined());
1739     auto& impl = castedThis->wrapped();
1740     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(*context, ec)));
1741     setDOMException(state, ec);
1742     return JSValue::encode(result);
1743 }
1744
1745
1746 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1747 {
1748     UNUSED_PARAM(state);
1749     UNUSED_PARAM(thisValue);
1750     JSValue decodedThisValue = JSValue::decode(thisValue);
1751     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1752     if (UNLIKELY(!castedThis)) {
1753         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
1754     }
1755     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
1756     if (!context)
1757         return JSValue::encode(jsUndefined());
1758     auto& impl = castedThis->wrapped();
1759     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttribute(*state, *context)));
1760     return JSValue::encode(result);
1761 }
1762
1763
1764 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, PropertyName)
1765 {
1766     UNUSED_PARAM(state);
1767     UNUSED_PARAM(thisValue);
1768     JSValue decodedThisValue = JSValue::decode(thisValue);
1769     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1770     if (UNLIKELY(!castedThis)) {
1771         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
1772     }
1773     ExceptionCode ec = 0;
1774     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
1775     if (!context)
1776         return JSValue::encode(jsUndefined());
1777     auto& impl = castedThis->wrapped();
1778     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(*state, *context, ec)));
1779     setDOMException(state, ec);
1780     return JSValue::encode(result);
1781 }
1782
1783
1784 EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1785 {
1786     UNUSED_PARAM(state);
1787     UNUSED_PARAM(thisValue);
1788     JSValue decodedThisValue = JSValue::decode(thisValue);
1789     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1790     if (UNLIKELY(!castedThis)) {
1791         return throwGetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
1792     }
1793     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
1794     if (!context)
1795         return JSValue::encode(jsUndefined());
1796     auto& impl = castedThis->wrapped();
1797     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpacesAttribute(*state, *context)));
1798     return JSValue::encode(result);
1799 }
1800
1801
1802 EncodedJSValue jsTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1803 {
1804     UNUSED_PARAM(state);
1805     UNUSED_PARAM(thisValue);
1806     JSValue decodedThisValue = JSValue::decode(thisValue);
1807     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1808     if (UNLIKELY(!castedThis)) {
1809         return throwGetterTypeError(*state, "TestObj", "withScriptArgumentsAndCallStackAttribute");
1810     }
1811     auto& impl = castedThis->wrapped();
1812     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.withScriptArgumentsAndCallStackAttribute()));
1813     return JSValue::encode(result);
1814 }
1815
1816
1817 #if ENABLE(Condition1)
1818 EncodedJSValue jsTestObjConditionalAttr1(ExecState* state, EncodedJSValue thisValue, PropertyName)
1819 {
1820     UNUSED_PARAM(state);
1821     UNUSED_PARAM(thisValue);
1822     JSValue decodedThisValue = JSValue::decode(thisValue);
1823     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1824     if (UNLIKELY(!castedThis)) {
1825         return throwGetterTypeError(*state, "TestObj", "conditionalAttr1");
1826     }
1827     auto& impl = castedThis->wrapped();
1828     JSValue result = jsNumber(impl.conditionalAttr1());
1829     return JSValue::encode(result);
1830 }
1831
1832 #endif
1833
1834 #if ENABLE(Condition1) && ENABLE(Condition2)
1835 EncodedJSValue jsTestObjConditionalAttr2(ExecState* state, EncodedJSValue thisValue, PropertyName)
1836 {
1837     UNUSED_PARAM(state);
1838     UNUSED_PARAM(thisValue);
1839     JSValue decodedThisValue = JSValue::decode(thisValue);
1840     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1841     if (UNLIKELY(!castedThis)) {
1842         return throwGetterTypeError(*state, "TestObj", "conditionalAttr2");
1843     }
1844     auto& impl = castedThis->wrapped();
1845     JSValue result = jsNumber(impl.conditionalAttr2());
1846     return JSValue::encode(result);
1847 }
1848
1849 #endif
1850
1851 #if ENABLE(Condition1) || ENABLE(Condition2)
1852 EncodedJSValue jsTestObjConditionalAttr3(ExecState* state, EncodedJSValue thisValue, PropertyName)
1853 {
1854     UNUSED_PARAM(state);
1855     UNUSED_PARAM(thisValue);
1856     JSValue decodedThisValue = JSValue::decode(thisValue);
1857     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1858     if (UNLIKELY(!castedThis)) {
1859         return throwGetterTypeError(*state, "TestObj", "conditionalAttr3");
1860     }
1861     auto& impl = castedThis->wrapped();
1862     JSValue result = jsNumber(impl.conditionalAttr3());
1863     return JSValue::encode(result);
1864 }
1865
1866 #endif
1867
1868 #if ENABLE(Condition1)
1869 EncodedJSValue jsTestObjConditionalAttr4Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
1870 {
1871     UNUSED_PARAM(state);
1872     UNUSED_PARAM(thisValue);
1873     JSValue decodedThisValue = JSValue::decode(thisValue);
1874     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1875     if (UNLIKELY(!castedThis)) {
1876         return throwGetterTypeError(*state, "TestObj", "conditionalAttr4");
1877     }
1878     return JSValue::encode(JSTestObjectA::getConstructor(state->vm(), castedThis->globalObject()));
1879 }
1880
1881 #endif
1882
1883 #if ENABLE(Condition1) && ENABLE(Condition2)
1884 EncodedJSValue jsTestObjConditionalAttr5Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
1885 {
1886     UNUSED_PARAM(state);
1887     UNUSED_PARAM(thisValue);
1888     JSValue decodedThisValue = JSValue::decode(thisValue);
1889     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1890     if (UNLIKELY(!castedThis)) {
1891         return throwGetterTypeError(*state, "TestObj", "conditionalAttr5");
1892     }
1893     return JSValue::encode(JSTestObjectB::getConstructor(state->vm(), castedThis->globalObject()));
1894 }
1895
1896 #endif
1897
1898 #if ENABLE(Condition1) || ENABLE(Condition2)
1899 EncodedJSValue jsTestObjConditionalAttr6Constructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
1900 {
1901     UNUSED_PARAM(state);
1902     UNUSED_PARAM(thisValue);
1903     JSValue decodedThisValue = JSValue::decode(thisValue);
1904     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1905     if (UNLIKELY(!castedThis)) {
1906         return throwGetterTypeError(*state, "TestObj", "conditionalAttr6");
1907     }
1908     return JSValue::encode(JSTestObjectC::getConstructor(state->vm(), castedThis->globalObject()));
1909 }
1910
1911 #endif
1912
1913 EncodedJSValue jsTestObjCachedAttribute1(ExecState* state, EncodedJSValue thisValue, PropertyName)
1914 {
1915     UNUSED_PARAM(state);
1916     UNUSED_PARAM(thisValue);
1917     JSValue decodedThisValue = JSValue::decode(thisValue);
1918     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1919     if (UNLIKELY(!castedThis)) {
1920         return throwGetterTypeError(*state, "TestObj", "cachedAttribute1");
1921     }
1922     if (JSValue cachedValue = castedThis->m_cachedAttribute1.get())
1923         return JSValue::encode(cachedValue);
1924     auto& impl = castedThis->wrapped();
1925     JSValue result = impl.cachedAttribute1();
1926     castedThis->m_cachedAttribute1.set(state->vm(), castedThis, result);
1927     return JSValue::encode(result);
1928 }
1929
1930
1931 EncodedJSValue jsTestObjCachedAttribute2(ExecState* state, EncodedJSValue thisValue, PropertyName)
1932 {
1933     UNUSED_PARAM(state);
1934     UNUSED_PARAM(thisValue);
1935     JSValue decodedThisValue = JSValue::decode(thisValue);
1936     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1937     if (UNLIKELY(!castedThis)) {
1938         return throwGetterTypeError(*state, "TestObj", "cachedAttribute2");
1939     }
1940     if (JSValue cachedValue = castedThis->m_cachedAttribute2.get())
1941         return JSValue::encode(cachedValue);
1942     auto& impl = castedThis->wrapped();
1943     JSValue result = impl.cachedAttribute2();
1944     castedThis->m_cachedAttribute2.set(state->vm(), castedThis, result);
1945     return JSValue::encode(result);
1946 }
1947
1948
1949 EncodedJSValue jsTestObjAnyAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
1950 {
1951     UNUSED_PARAM(state);
1952     UNUSED_PARAM(thisValue);
1953     JSValue decodedThisValue = JSValue::decode(thisValue);
1954     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1955     if (UNLIKELY(!castedThis)) {
1956         return throwGetterTypeError(*state, "TestObj", "anyAttribute");
1957     }
1958     auto& impl = castedThis->wrapped();
1959     JSValue result = impl.anyAttribute();
1960     return JSValue::encode(result);
1961 }
1962
1963
1964 EncodedJSValue jsTestObjContentDocument(ExecState* state, EncodedJSValue thisValue, PropertyName)
1965 {
1966     UNUSED_PARAM(state);
1967     UNUSED_PARAM(thisValue);
1968     JSValue decodedThisValue = JSValue::decode(thisValue);
1969     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1970     if (UNLIKELY(!castedThis)) {
1971         return throwGetterTypeError(*state, "TestObj", "contentDocument");
1972     }
1973     auto& impl = castedThis->wrapped();
1974     return JSValue::encode(shouldAllowAccessToNode(state, impl.contentDocument()) ? toJS(state, castedThis->globalObject(), WTF::getPtr(impl.contentDocument())) : jsNull());
1975 }
1976
1977
1978 EncodedJSValue jsTestObjMutablePoint(ExecState* state, EncodedJSValue thisValue, PropertyName)
1979 {
1980     UNUSED_PARAM(state);
1981     UNUSED_PARAM(thisValue);
1982     JSValue decodedThisValue = JSValue::decode(thisValue);
1983     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1984     if (UNLIKELY(!castedThis)) {
1985         return throwGetterTypeError(*state, "TestObj", "mutablePoint");
1986     }
1987     auto& impl = castedThis->wrapped();
1988     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(SVGStaticPropertyTearOff<TestObj, SVGPoint>::create(impl, impl.mutablePoint(), &TestObj::updateMutablePoint)));
1989     return JSValue::encode(result);
1990 }
1991
1992
1993 EncodedJSValue jsTestObjImmutablePoint(ExecState* state, EncodedJSValue thisValue, PropertyName)
1994 {
1995     UNUSED_PARAM(state);
1996     UNUSED_PARAM(thisValue);
1997     JSValue decodedThisValue = JSValue::decode(thisValue);
1998     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
1999     if (UNLIKELY(!castedThis)) {
2000         return throwGetterTypeError(*state, "TestObj", "immutablePoint");
2001     }
2002     auto& impl = castedThis->wrapped();
2003     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePoint())));
2004     return JSValue::encode(result);
2005 }
2006
2007
2008 EncodedJSValue jsTestObjStrawberry(ExecState* state, EncodedJSValue thisValue, PropertyName)
2009 {
2010     UNUSED_PARAM(state);
2011     UNUSED_PARAM(thisValue);
2012     JSValue decodedThisValue = JSValue::decode(thisValue);
2013     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2014     if (UNLIKELY(!castedThis)) {
2015         return throwGetterTypeError(*state, "TestObj", "strawberry");
2016     }
2017     auto& impl = castedThis->wrapped();
2018     JSValue result = jsNumber(impl.blueberry());
2019     return JSValue::encode(result);
2020 }
2021
2022
2023 EncodedJSValue jsTestObjStrictFloat(ExecState* state, EncodedJSValue thisValue, PropertyName)
2024 {
2025     UNUSED_PARAM(state);
2026     UNUSED_PARAM(thisValue);
2027     JSValue decodedThisValue = JSValue::decode(thisValue);
2028     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2029     if (UNLIKELY(!castedThis)) {
2030         return throwGetterTypeError(*state, "TestObj", "strictFloat");
2031     }
2032     auto& impl = castedThis->wrapped();
2033     JSValue result = jsNumber(impl.strictFloat());
2034     return JSValue::encode(result);
2035 }
2036
2037
2038 EncodedJSValue jsTestObjDescription(ExecState* state, EncodedJSValue thisValue, PropertyName)
2039 {
2040     UNUSED_PARAM(state);
2041     UNUSED_PARAM(thisValue);
2042     JSValue decodedThisValue = JSValue::decode(thisValue);
2043     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2044     if (UNLIKELY(!castedThis)) {
2045         return throwGetterTypeError(*state, "TestObj", "description");
2046     }
2047     auto& impl = castedThis->wrapped();
2048     JSValue result = jsNumber(impl.description());
2049     return JSValue::encode(result);
2050 }
2051
2052
2053 EncodedJSValue jsTestObjId(ExecState* state, EncodedJSValue thisValue, PropertyName)
2054 {
2055     UNUSED_PARAM(state);
2056     UNUSED_PARAM(thisValue);
2057     JSValue decodedThisValue = JSValue::decode(thisValue);
2058     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2059     if (UNLIKELY(!castedThis)) {
2060         return throwGetterTypeError(*state, "TestObj", "id");
2061     }
2062     auto& impl = castedThis->wrapped();
2063     JSValue result = jsNumber(impl.id());
2064     return JSValue::encode(result);
2065 }
2066
2067
2068 EncodedJSValue jsTestObjHash(ExecState* state, EncodedJSValue thisValue, PropertyName)
2069 {
2070     UNUSED_PARAM(state);
2071     UNUSED_PARAM(thisValue);
2072     JSValue decodedThisValue = JSValue::decode(thisValue);
2073     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2074     if (UNLIKELY(!castedThis)) {
2075         return throwGetterTypeError(*state, "TestObj", "hash");
2076     }
2077     auto& impl = castedThis->wrapped();
2078     JSValue result = jsStringWithCache(state, impl.hash());
2079     return JSValue::encode(result);
2080 }
2081
2082
2083 EncodedJSValue jsTestObjReplaceableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2084 {
2085     UNUSED_PARAM(state);
2086     UNUSED_PARAM(thisValue);
2087     JSValue decodedThisValue = JSValue::decode(thisValue);
2088     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2089     if (UNLIKELY(!castedThis)) {
2090         return throwGetterTypeError(*state, "TestObj", "replaceableAttribute");
2091     }
2092     auto& impl = castedThis->wrapped();
2093     JSValue result = jsNumber(impl.replaceableAttribute());
2094     return JSValue::encode(result);
2095 }
2096
2097
2098 EncodedJSValue jsTestObjNullableDoubleAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2099 {
2100     UNUSED_PARAM(state);
2101     UNUSED_PARAM(thisValue);
2102     JSValue decodedThisValue = JSValue::decode(thisValue);
2103     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2104     if (UNLIKELY(!castedThis)) {
2105         return throwGetterTypeError(*state, "TestObj", "nullableDoubleAttribute");
2106     }
2107     auto& impl = castedThis->wrapped();
2108     JSValue result = toNullableJSNumber(impl.nullableDoubleAttribute());
2109     return JSValue::encode(result);
2110 }
2111
2112
2113 EncodedJSValue jsTestObjNullableLongAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2114 {
2115     UNUSED_PARAM(state);
2116     UNUSED_PARAM(thisValue);
2117     JSValue decodedThisValue = JSValue::decode(thisValue);
2118     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2119     if (UNLIKELY(!castedThis)) {
2120         return throwGetterTypeError(*state, "TestObj", "nullableLongAttribute");
2121     }
2122     auto& impl = castedThis->wrapped();
2123     JSValue result = toNullableJSNumber(impl.nullableLongAttribute());
2124     return JSValue::encode(result);
2125 }
2126
2127
2128 EncodedJSValue jsTestObjNullableBooleanAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2129 {
2130     UNUSED_PARAM(state);
2131     UNUSED_PARAM(thisValue);
2132     JSValue decodedThisValue = JSValue::decode(thisValue);
2133     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2134     if (UNLIKELY(!castedThis)) {
2135         return throwGetterTypeError(*state, "TestObj", "nullableBooleanAttribute");
2136     }
2137     auto& impl = castedThis->wrapped();
2138     JSValue result = jsBoolean(impl.nullableBooleanAttribute());
2139     return JSValue::encode(result);
2140 }
2141
2142
2143 EncodedJSValue jsTestObjNullableStringAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2144 {
2145     UNUSED_PARAM(state);
2146     UNUSED_PARAM(thisValue);
2147     JSValue decodedThisValue = JSValue::decode(thisValue);
2148     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2149     if (UNLIKELY(!castedThis)) {
2150         return throwGetterTypeError(*state, "TestObj", "nullableStringAttribute");
2151     }
2152     auto& impl = castedThis->wrapped();
2153     JSValue result = jsStringOrNull(state, impl.nullableStringAttribute());
2154     return JSValue::encode(result);
2155 }
2156
2157
2158 EncodedJSValue jsTestObjNullableLongSettableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2159 {
2160     UNUSED_PARAM(state);
2161     UNUSED_PARAM(thisValue);
2162     JSValue decodedThisValue = JSValue::decode(thisValue);
2163     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2164     if (UNLIKELY(!castedThis)) {
2165         return throwGetterTypeError(*state, "TestObj", "nullableLongSettableAttribute");
2166     }
2167     auto& impl = castedThis->wrapped();
2168     JSValue result = toNullableJSNumber(impl.nullableLongSettableAttribute());
2169     return JSValue::encode(result);
2170 }
2171
2172
2173 EncodedJSValue jsTestObjNullableStringSettableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2174 {
2175     UNUSED_PARAM(state);
2176     UNUSED_PARAM(thisValue);
2177     JSValue decodedThisValue = JSValue::decode(thisValue);
2178     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2179     if (UNLIKELY(!castedThis)) {
2180         return throwGetterTypeError(*state, "TestObj", "nullableStringSettableAttribute");
2181     }
2182     auto& impl = castedThis->wrapped();
2183     JSValue result = jsStringOrNull(state, impl.nullableStringSettableAttribute());
2184     return JSValue::encode(result);
2185 }
2186
2187
2188 EncodedJSValue jsTestObjNullableStringValue(ExecState* state, EncodedJSValue thisValue, PropertyName)
2189 {
2190     UNUSED_PARAM(state);
2191     UNUSED_PARAM(thisValue);
2192     JSValue decodedThisValue = JSValue::decode(thisValue);
2193     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2194     if (UNLIKELY(!castedThis)) {
2195         return throwGetterTypeError(*state, "TestObj", "nullableStringValue");
2196     }
2197     ExceptionCode ec = 0;
2198     auto& impl = castedThis->wrapped();
2199     JSValue result = toNullableJSNumber(impl.nullableStringValue(ec));
2200     setDOMException(state, ec);
2201     return JSValue::encode(result);
2202 }
2203
2204
2205 EncodedJSValue jsTestObjAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2206 {
2207     UNUSED_PARAM(state);
2208     UNUSED_PARAM(thisValue);
2209     JSValue decodedThisValue = JSValue::decode(thisValue);
2210     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2211     if (UNLIKELY(!castedThis)) {
2212         return throwGetterTypeError(*state, "TestObj", "attribute");
2213     }
2214     auto& impl = castedThis->wrapped();
2215     JSValue result = jsStringWithCache(state, impl.attribute());
2216     return JSValue::encode(result);
2217 }
2218
2219
2220 EncodedJSValue jsTestObjAttributeWithReservedEnumType(ExecState* state, EncodedJSValue thisValue, PropertyName)
2221 {
2222     UNUSED_PARAM(state);
2223     UNUSED_PARAM(thisValue);
2224     JSValue decodedThisValue = JSValue::decode(thisValue);
2225     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2226     if (UNLIKELY(!castedThis)) {
2227         return throwGetterTypeError(*state, "TestObj", "attributeWithReservedEnumType");
2228     }
2229     auto& impl = castedThis->wrapped();
2230     JSValue result = jsStringWithCache(state, impl.attributeWithReservedEnumType());
2231     return JSValue::encode(result);
2232 }
2233
2234
2235 EncodedJSValue jsTestObjPutForwardsAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2236 {
2237     UNUSED_PARAM(state);
2238     UNUSED_PARAM(thisValue);
2239     JSValue decodedThisValue = JSValue::decode(thisValue);
2240     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2241     if (UNLIKELY(!castedThis)) {
2242         return throwGetterTypeError(*state, "TestObj", "putForwardsAttribute");
2243     }
2244     auto& impl = castedThis->wrapped();
2245     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.putForwardsAttribute()));
2246     return JSValue::encode(result);
2247 }
2248
2249
2250 EncodedJSValue jsTestObjPutForwardsNullableAttribute(ExecState* state, EncodedJSValue thisValue, PropertyName)
2251 {
2252     UNUSED_PARAM(state);
2253     UNUSED_PARAM(thisValue);
2254     JSValue decodedThisValue = JSValue::decode(thisValue);
2255     auto* castedThis = jsDynamicCast<JSTestObj*>(decodedThisValue);
2256     if (UNLIKELY(!castedThis)) {
2257         return throwGetterTypeError(*state, "TestObj", "putForwardsNullableAttribute");
2258     }
2259     auto& impl = castedThis->wrapped();
2260     JSValue result = toJS(state, castedThis->globalObject(), WTF::getPtr(impl.putForwardsNullableAttribute()));
2261     return JSValue::encode(result);
2262 }
2263
2264
2265 EncodedJSValue jsTestObjConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
2266 {
2267     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue));
2268     if (UNLIKELY(!domObject))
2269         return throwVMTypeError(state);
2270     return JSValue::encode(JSTestObj::getConstructor(state->vm(), domObject->globalObject()));
2271 }
2272
2273 bool setJSTestObjConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2274 {
2275     JSValue value = JSValue::decode(encodedValue);
2276     JSTestObjPrototype* domObject = jsDynamicCast<JSTestObjPrototype*>(JSValue::decode(thisValue));
2277     if (UNLIKELY(!domObject)) {
2278         throwVMTypeError(state);
2279         return false;
2280     }
2281     // Shadowing a built-in constructor
2282     return domObject->putDirect(state->vm(), state->propertyNames().constructor, value);
2283 }
2284
2285 bool setJSTestObjConstructorStaticStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2286 {
2287     JSValue value = JSValue::decode(encodedValue);
2288     String nativeValue = value.toWTFString(state);
2289     if (UNLIKELY(state->hadException()))
2290         return false;
2291     TestObj::setStaticStringAttr(nativeValue);
2292     return true;
2293 }
2294
2295
2296 bool setJSTestObjTestSubObjEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2297 {
2298     JSValue value = JSValue::decode(encodedValue);
2299     UNUSED_PARAM(thisValue);
2300     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2301     if (UNLIKELY(!castedThis)) {
2302         return throwSetterTypeError(*state, "TestObj", "TestSubObjEnabledBySetting");
2303     }
2304     // Shadowing a built-in constructor.
2305     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "TestSubObjEnabledBySetting"), value);
2306 }
2307
2308
2309 bool setJSTestObjEnumAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2310 {
2311     JSValue value = JSValue::decode(encodedValue);
2312     UNUSED_PARAM(thisValue);
2313     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2314     if (UNLIKELY(!castedThis)) {
2315         return throwSetterTypeError(*state, "TestObj", "enumAttr");
2316     }
2317     auto& impl = castedThis->wrapped();
2318     auto nativeValue = parseTestEnumType(*state, value);
2319     if (UNLIKELY(state->hadException()))
2320         return false;
2321     if (UNLIKELY(!nativeValue))
2322         return false;
2323     impl.setEnumAttr(nativeValue.value());
2324     return true;
2325 }
2326
2327
2328 bool setJSTestObjByteAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2329 {
2330     JSValue value = JSValue::decode(encodedValue);
2331     UNUSED_PARAM(thisValue);
2332     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2333     if (UNLIKELY(!castedThis)) {
2334         return throwSetterTypeError(*state, "TestObj", "byteAttr");
2335     }
2336     auto& impl = castedThis->wrapped();
2337     int8_t nativeValue = toInt8(state, value, NormalConversion);
2338     if (UNLIKELY(state->hadException()))
2339         return false;
2340     impl.setByteAttr(nativeValue);
2341     return true;
2342 }
2343
2344
2345 bool setJSTestObjOctetAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2346 {
2347     JSValue value = JSValue::decode(encodedValue);
2348     UNUSED_PARAM(thisValue);
2349     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2350     if (UNLIKELY(!castedThis)) {
2351         return throwSetterTypeError(*state, "TestObj", "octetAttr");
2352     }
2353     auto& impl = castedThis->wrapped();
2354     uint8_t nativeValue = toUInt8(state, value, NormalConversion);
2355     if (UNLIKELY(state->hadException()))
2356         return false;
2357     impl.setOctetAttr(nativeValue);
2358     return true;
2359 }
2360
2361
2362 bool setJSTestObjShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2363 {
2364     JSValue value = JSValue::decode(encodedValue);
2365     UNUSED_PARAM(thisValue);
2366     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2367     if (UNLIKELY(!castedThis)) {
2368         return throwSetterTypeError(*state, "TestObj", "shortAttr");
2369     }
2370     auto& impl = castedThis->wrapped();
2371     int16_t nativeValue = toInt16(state, value, NormalConversion);
2372     if (UNLIKELY(state->hadException()))
2373         return false;
2374     impl.setShortAttr(nativeValue);
2375     return true;
2376 }
2377
2378
2379 bool setJSTestObjClampedShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2380 {
2381     JSValue value = JSValue::decode(encodedValue);
2382     UNUSED_PARAM(thisValue);
2383     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2384     if (UNLIKELY(!castedThis)) {
2385         return throwSetterTypeError(*state, "TestObj", "clampedShortAttr");
2386     }
2387     auto& impl = castedThis->wrapped();
2388     int16_t nativeValue = toInt16(state, value, Clamp);
2389     if (UNLIKELY(state->hadException()))
2390         return false;
2391     impl.setClampedShortAttr(nativeValue);
2392     return true;
2393 }
2394
2395
2396 bool setJSTestObjEnforceRangeShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2397 {
2398     JSValue value = JSValue::decode(encodedValue);
2399     UNUSED_PARAM(thisValue);
2400     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2401     if (UNLIKELY(!castedThis)) {
2402         return throwSetterTypeError(*state, "TestObj", "enforceRangeShortAttr");
2403     }
2404     auto& impl = castedThis->wrapped();
2405     int16_t nativeValue = toInt16(state, value, EnforceRange);
2406     if (UNLIKELY(state->hadException()))
2407         return false;
2408     impl.setEnforceRangeShortAttr(nativeValue);
2409     return true;
2410 }
2411
2412
2413 bool setJSTestObjUnsignedShortAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2414 {
2415     JSValue value = JSValue::decode(encodedValue);
2416     UNUSED_PARAM(thisValue);
2417     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2418     if (UNLIKELY(!castedThis)) {
2419         return throwSetterTypeError(*state, "TestObj", "unsignedShortAttr");
2420     }
2421     auto& impl = castedThis->wrapped();
2422     uint16_t nativeValue = toUInt16(state, value, NormalConversion);
2423     if (UNLIKELY(state->hadException()))
2424         return false;
2425     impl.setUnsignedShortAttr(nativeValue);
2426     return true;
2427 }
2428
2429
2430 bool setJSTestObjLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2431 {
2432     JSValue value = JSValue::decode(encodedValue);
2433     UNUSED_PARAM(thisValue);
2434     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2435     if (UNLIKELY(!castedThis)) {
2436         return throwSetterTypeError(*state, "TestObj", "longAttr");
2437     }
2438     auto& impl = castedThis->wrapped();
2439     int nativeValue = toInt32(state, value, NormalConversion);
2440     if (UNLIKELY(state->hadException()))
2441         return false;
2442     impl.setLongAttr(nativeValue);
2443     return true;
2444 }
2445
2446
2447 bool setJSTestObjLongLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2448 {
2449     JSValue value = JSValue::decode(encodedValue);
2450     UNUSED_PARAM(thisValue);
2451     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2452     if (UNLIKELY(!castedThis)) {
2453         return throwSetterTypeError(*state, "TestObj", "longLongAttr");
2454     }
2455     auto& impl = castedThis->wrapped();
2456     long long nativeValue = toInt64(state, value, NormalConversion);
2457     if (UNLIKELY(state->hadException()))
2458         return false;
2459     impl.setLongLongAttr(nativeValue);
2460     return true;
2461 }
2462
2463
2464 bool setJSTestObjUnsignedLongLongAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2465 {
2466     JSValue value = JSValue::decode(encodedValue);
2467     UNUSED_PARAM(thisValue);
2468     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2469     if (UNLIKELY(!castedThis)) {
2470         return throwSetterTypeError(*state, "TestObj", "unsignedLongLongAttr");
2471     }
2472     auto& impl = castedThis->wrapped();
2473     unsigned long long nativeValue = toUInt64(state, value, NormalConversion);
2474     if (UNLIKELY(state->hadException()))
2475         return false;
2476     impl.setUnsignedLongLongAttr(nativeValue);
2477     return true;
2478 }
2479
2480
2481 bool setJSTestObjStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2482 {
2483     JSValue value = JSValue::decode(encodedValue);
2484     UNUSED_PARAM(thisValue);
2485     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2486     if (UNLIKELY(!castedThis)) {
2487         return throwSetterTypeError(*state, "TestObj", "stringAttr");
2488     }
2489     auto& impl = castedThis->wrapped();
2490     String nativeValue = value.toWTFString(state);
2491     if (UNLIKELY(state->hadException()))
2492         return false;
2493     impl.setStringAttr(nativeValue);
2494     return true;
2495 }
2496
2497
2498 bool setJSTestObjTestObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2499 {
2500     JSValue value = JSValue::decode(encodedValue);
2501     UNUSED_PARAM(thisValue);
2502     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2503     if (UNLIKELY(!castedThis)) {
2504         return throwSetterTypeError(*state, "TestObj", "testObjAttr");
2505     }
2506     auto& impl = castedThis->wrapped();
2507     TestObj* nativeValue = JSTestObj::toWrapped(value);
2508     if (UNLIKELY(state->hadException()))
2509         return false;
2510     impl.setTestObjAttr(nativeValue);
2511     return true;
2512 }
2513
2514
2515 bool setJSTestObjLenientTestObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2516 {
2517     JSValue value = JSValue::decode(encodedValue);
2518     UNUSED_PARAM(thisValue);
2519     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2520     if (UNLIKELY(!castedThis)) {
2521         return false;
2522     }
2523     auto& impl = castedThis->wrapped();
2524     TestObj* nativeValue = JSTestObj::toWrapped(value);
2525     if (UNLIKELY(state->hadException()))
2526         return false;
2527     impl.setLenientTestObjAttr(nativeValue);
2528     return true;
2529 }
2530
2531
2532 bool setJSTestObjStringAttrTreatingNullAsEmptyString(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2533 {
2534     JSValue value = JSValue::decode(encodedValue);
2535     UNUSED_PARAM(thisValue);
2536     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2537     if (UNLIKELY(!castedThis)) {
2538         return throwSetterTypeError(*state, "TestObj", "stringAttrTreatingNullAsEmptyString");
2539     }
2540     auto& impl = castedThis->wrapped();
2541     String nativeValue = valueToStringTreatingNullAsEmptyString(state, value);
2542     if (UNLIKELY(state->hadException()))
2543         return false;
2544     impl.setStringAttrTreatingNullAsEmptyString(nativeValue);
2545     return true;
2546 }
2547
2548
2549 bool setJSTestObjXMLObjAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2550 {
2551     JSValue value = JSValue::decode(encodedValue);
2552     UNUSED_PARAM(thisValue);
2553     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2554     if (UNLIKELY(!castedThis)) {
2555         return throwSetterTypeError(*state, "TestObj", "XMLObjAttr");
2556     }
2557     auto& impl = castedThis->wrapped();
2558     TestObj* nativeValue = JSTestObj::toWrapped(value);
2559     if (UNLIKELY(state->hadException()))
2560         return false;
2561     impl.setXMLObjAttr(nativeValue);
2562     return true;
2563 }
2564
2565
2566 bool setJSTestObjCreate(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2567 {
2568     JSValue value = JSValue::decode(encodedValue);
2569     UNUSED_PARAM(thisValue);
2570     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2571     if (UNLIKELY(!castedThis)) {
2572         return throwSetterTypeError(*state, "TestObj", "create");
2573     }
2574     auto& impl = castedThis->wrapped();
2575     bool nativeValue = value.toBoolean(state);
2576     if (UNLIKELY(state->hadException()))
2577         return false;
2578     impl.setCreate(nativeValue);
2579     return true;
2580 }
2581
2582
2583 bool setJSTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2584 {
2585     JSValue value = JSValue::decode(encodedValue);
2586     UNUSED_PARAM(thisValue);
2587     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2588     if (UNLIKELY(!castedThis)) {
2589         return throwSetterTypeError(*state, "TestObj", "reflectedStringAttr");
2590     }
2591     auto& impl = castedThis->wrapped();
2592     String nativeValue = value.toWTFString(state);
2593     if (UNLIKELY(state->hadException()))
2594         return false;
2595     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedstringattrAttr, nativeValue);
2596     return true;
2597 }
2598
2599
2600 bool setJSTestObjReflectedIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2601 {
2602     JSValue value = JSValue::decode(encodedValue);
2603     UNUSED_PARAM(thisValue);
2604     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2605     if (UNLIKELY(!castedThis)) {
2606         return throwSetterTypeError(*state, "TestObj", "reflectedIntegralAttr");
2607     }
2608     auto& impl = castedThis->wrapped();
2609     int nativeValue = toInt32(state, value, NormalConversion);
2610     if (UNLIKELY(state->hadException()))
2611         return false;
2612     impl.setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, nativeValue);
2613     return true;
2614 }
2615
2616
2617 bool setJSTestObjReflectedUnsignedIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2618 {
2619     JSValue value = JSValue::decode(encodedValue);
2620     UNUSED_PARAM(thisValue);
2621     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2622     if (UNLIKELY(!castedThis)) {
2623         return throwSetterTypeError(*state, "TestObj", "reflectedUnsignedIntegralAttr");
2624     }
2625     auto& impl = castedThis->wrapped();
2626     unsigned nativeValue = toUInt32(state, value, NormalConversion);
2627     if (UNLIKELY(state->hadException()))
2628         return false;
2629     impl.setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, nativeValue);
2630     return true;
2631 }
2632
2633
2634 bool setJSTestObjReflectedBooleanAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2635 {
2636     JSValue value = JSValue::decode(encodedValue);
2637     UNUSED_PARAM(thisValue);
2638     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2639     if (UNLIKELY(!castedThis)) {
2640         return throwSetterTypeError(*state, "TestObj", "reflectedBooleanAttr");
2641     }
2642     auto& impl = castedThis->wrapped();
2643     bool nativeValue = value.toBoolean(state);
2644     if (UNLIKELY(state->hadException()))
2645         return false;
2646     impl.setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, nativeValue);
2647     return true;
2648 }
2649
2650
2651 bool setJSTestObjReflectedURLAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2652 {
2653     JSValue value = JSValue::decode(encodedValue);
2654     UNUSED_PARAM(thisValue);
2655     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2656     if (UNLIKELY(!castedThis)) {
2657         return throwSetterTypeError(*state, "TestObj", "reflectedURLAttr");
2658     }
2659     auto& impl = castedThis->wrapped();
2660     String nativeValue = value.toWTFString(state);
2661     if (UNLIKELY(state->hadException()))
2662         return false;
2663     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::reflectedurlattrAttr, nativeValue);
2664     return true;
2665 }
2666
2667
2668 bool setJSTestObjReflectedStringAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2669 {
2670     JSValue value = JSValue::decode(encodedValue);
2671     UNUSED_PARAM(thisValue);
2672     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2673     if (UNLIKELY(!castedThis)) {
2674         return throwSetterTypeError(*state, "TestObj", "reflectedStringAttr");
2675     }
2676     auto& impl = castedThis->wrapped();
2677     String nativeValue = value.toWTFString(state);
2678     if (UNLIKELY(state->hadException()))
2679         return false;
2680     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentStringAttrAttr, nativeValue);
2681     return true;
2682 }
2683
2684
2685 bool setJSTestObjReflectedCustomIntegralAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2686 {
2687     JSValue value = JSValue::decode(encodedValue);
2688     UNUSED_PARAM(thisValue);
2689     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2690     if (UNLIKELY(!castedThis)) {
2691         return throwSetterTypeError(*state, "TestObj", "reflectedCustomIntegralAttr");
2692     }
2693     auto& impl = castedThis->wrapped();
2694     int nativeValue = toInt32(state, value, NormalConversion);
2695     if (UNLIKELY(state->hadException()))
2696         return false;
2697     impl.setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, nativeValue);
2698     return true;
2699 }
2700
2701
2702 bool setJSTestObjReflectedCustomBooleanAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2703 {
2704     JSValue value = JSValue::decode(encodedValue);
2705     UNUSED_PARAM(thisValue);
2706     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2707     if (UNLIKELY(!castedThis)) {
2708         return throwSetterTypeError(*state, "TestObj", "reflectedCustomBooleanAttr");
2709     }
2710     auto& impl = castedThis->wrapped();
2711     bool nativeValue = value.toBoolean(state);
2712     if (UNLIKELY(state->hadException()))
2713         return false;
2714     impl.setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, nativeValue);
2715     return true;
2716 }
2717
2718
2719 bool setJSTestObjReflectedCustomURLAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2720 {
2721     JSValue value = JSValue::decode(encodedValue);
2722     UNUSED_PARAM(thisValue);
2723     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2724     if (UNLIKELY(!castedThis)) {
2725         return throwSetterTypeError(*state, "TestObj", "reflectedCustomURLAttr");
2726     }
2727     auto& impl = castedThis->wrapped();
2728     String nativeValue = value.toWTFString(state);
2729     if (UNLIKELY(state->hadException()))
2730         return false;
2731     impl.setAttributeWithoutSynchronization(WebCore::HTMLNames::customContentURLAttrAttr, nativeValue);
2732     return true;
2733 }
2734
2735
2736 #if ENABLE(TEST_FEATURE)
2737 bool setJSTestObjEnabledAtRuntimeAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2738 {
2739     JSValue value = JSValue::decode(encodedValue);
2740     UNUSED_PARAM(thisValue);
2741     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2742     if (UNLIKELY(!castedThis)) {
2743         return throwSetterTypeError(*state, "TestObj", "enabledAtRuntimeAttribute");
2744     }
2745     auto& impl = castedThis->wrapped();
2746     String nativeValue = value.toWTFString(state);
2747     if (UNLIKELY(state->hadException()))
2748         return false;
2749     impl.setEnabledAtRuntimeAttribute(nativeValue);
2750     return true;
2751 }
2752
2753 #endif
2754
2755 bool setJSTestObjTypedArrayAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2756 {
2757     JSValue value = JSValue::decode(encodedValue);
2758     UNUSED_PARAM(thisValue);
2759     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2760     if (UNLIKELY(!castedThis)) {
2761         return throwSetterTypeError(*state, "TestObj", "typedArrayAttr");
2762     }
2763     auto& impl = castedThis->wrapped();
2764     RefPtr<Float32Array> nativeValue = toFloat32Array(value);
2765     if (UNLIKELY(state->hadException()))
2766         return false;
2767     impl.setTypedArrayAttr(nativeValue.get());
2768     return true;
2769 }
2770
2771
2772 bool setJSTestObjAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2773 {
2774     JSValue value = JSValue::decode(encodedValue);
2775     UNUSED_PARAM(thisValue);
2776     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2777     if (UNLIKELY(!castedThis)) {
2778         return throwSetterTypeError(*state, "TestObj", "attrWithGetterException");
2779     }
2780     auto& impl = castedThis->wrapped();
2781     int nativeValue = toInt32(state, value, NormalConversion);
2782     if (UNLIKELY(state->hadException()))
2783         return false;
2784     impl.setAttrWithGetterException(nativeValue);
2785     return true;
2786 }
2787
2788
2789 bool setJSTestObjAttrWithGetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2790 {
2791     JSValue value = JSValue::decode(encodedValue);
2792     UNUSED_PARAM(thisValue);
2793     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2794     if (UNLIKELY(!castedThis)) {
2795         return throwSetterTypeError(*state, "TestObj", "attrWithGetterExceptionWithMessage");
2796     }
2797     auto& impl = castedThis->wrapped();
2798     int nativeValue = toInt32(state, value, NormalConversion);
2799     if (UNLIKELY(state->hadException()))
2800         return false;
2801     impl.setAttrWithGetterExceptionWithMessage(nativeValue);
2802     return true;
2803 }
2804
2805
2806 bool setJSTestObjAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2807 {
2808     JSValue value = JSValue::decode(encodedValue);
2809     UNUSED_PARAM(thisValue);
2810     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2811     if (UNLIKELY(!castedThis)) {
2812         return throwSetterTypeError(*state, "TestObj", "attrWithSetterException");
2813     }
2814     auto& impl = castedThis->wrapped();
2815     ExceptionCode ec = 0;
2816     int nativeValue = toInt32(state, value, NormalConversion);
2817     if (UNLIKELY(state->hadException()))
2818         return false;
2819     impl.setAttrWithSetterException(nativeValue, ec);
2820     setDOMException(state, ec);
2821     return true;
2822 }
2823
2824
2825 bool setJSTestObjAttrWithSetterExceptionWithMessage(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2826 {
2827     JSValue value = JSValue::decode(encodedValue);
2828     UNUSED_PARAM(thisValue);
2829     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2830     if (UNLIKELY(!castedThis)) {
2831         return throwSetterTypeError(*state, "TestObj", "attrWithSetterExceptionWithMessage");
2832     }
2833     auto& impl = castedThis->wrapped();
2834     ExceptionCodeWithMessage ec;
2835     int nativeValue = toInt32(state, value, NormalConversion);
2836     if (UNLIKELY(state->hadException()))
2837         return false;
2838     impl.setAttrWithSetterExceptionWithMessage(nativeValue, ec);
2839     setDOMException(state, ec);
2840     return true;
2841 }
2842
2843
2844 bool setJSTestObjStringAttrWithGetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2845 {
2846     JSValue value = JSValue::decode(encodedValue);
2847     UNUSED_PARAM(thisValue);
2848     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2849     if (UNLIKELY(!castedThis)) {
2850         return throwSetterTypeError(*state, "TestObj", "stringAttrWithGetterException");
2851     }
2852     auto& impl = castedThis->wrapped();
2853     String nativeValue = value.toWTFString(state);
2854     if (UNLIKELY(state->hadException()))
2855         return false;
2856     impl.setStringAttrWithGetterException(nativeValue);
2857     return true;
2858 }
2859
2860
2861 bool setJSTestObjStringAttrWithSetterException(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2862 {
2863     JSValue value = JSValue::decode(encodedValue);
2864     UNUSED_PARAM(thisValue);
2865     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2866     if (UNLIKELY(!castedThis)) {
2867         return throwSetterTypeError(*state, "TestObj", "stringAttrWithSetterException");
2868     }
2869     auto& impl = castedThis->wrapped();
2870     ExceptionCode ec = 0;
2871     String nativeValue = value.toWTFString(state);
2872     if (UNLIKELY(state->hadException()))
2873         return false;
2874     impl.setStringAttrWithSetterException(nativeValue, ec);
2875     setDOMException(state, ec);
2876     return true;
2877 }
2878
2879
2880 bool setJSTestObjStrictTypeCheckingAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2881 {
2882     JSValue value = JSValue::decode(encodedValue);
2883     UNUSED_PARAM(thisValue);
2884     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2885     if (UNLIKELY(!castedThis)) {
2886         return throwSetterTypeError(*state, "TestObj", "strictTypeCheckingAttribute");
2887     }
2888     auto& impl = castedThis->wrapped();
2889     if (UNLIKELY(!value.isUndefinedOrNull() && !value.inherits(JSTestObj::info()))) {
2890         throwAttributeTypeError(*state, "TestObj", "strictTypeCheckingAttribute", "TestObj");
2891         return false;
2892     };
2893     TestObj* nativeValue = JSTestObj::toWrapped(value);
2894     if (UNLIKELY(state->hadException()))
2895         return false;
2896     impl.setStrictTypeCheckingAttribute(nativeValue);
2897     return true;
2898 }
2899
2900
2901 bool setJSTestObjCustomAttr(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2902 {
2903     JSValue value = JSValue::decode(encodedValue);
2904     UNUSED_PARAM(thisValue);
2905     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2906     if (UNLIKELY(!castedThis)) {
2907         return throwSetterTypeError(*state, "TestObj", "customAttr");
2908     }
2909     castedThis->setCustomAttr(*state, value);
2910     return true;
2911 }
2912
2913
2914 bool setJSTestObjOnfoo(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2915 {
2916     JSValue value = JSValue::decode(encodedValue);
2917     UNUSED_PARAM(thisValue);
2918     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2919     if (UNLIKELY(!castedThis)) {
2920         return throwSetterTypeError(*state, "TestObj", "onfoo");
2921     }
2922     setEventHandlerAttribute(*state, *castedThis, castedThis->wrapped(), eventNames().fooEvent, value);
2923     return true;
2924 }
2925
2926
2927 bool setJSTestObjOnwebkitfoo(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2928 {
2929     JSValue value = JSValue::decode(encodedValue);
2930     UNUSED_PARAM(thisValue);
2931     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2932     if (UNLIKELY(!castedThis)) {
2933         return throwSetterTypeError(*state, "TestObj", "onwebkitfoo");
2934     }
2935     setEventHandlerAttribute(*state, *castedThis, castedThis->wrapped(), eventNames().fooEvent, value);
2936     return true;
2937 }
2938
2939
2940 bool setJSTestObjWithScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2941 {
2942     JSValue value = JSValue::decode(encodedValue);
2943     UNUSED_PARAM(thisValue);
2944     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2945     if (UNLIKELY(!castedThis)) {
2946         return throwSetterTypeError(*state, "TestObj", "withScriptStateAttribute");
2947     }
2948     auto& impl = castedThis->wrapped();
2949     int nativeValue = toInt32(state, value, NormalConversion);
2950     if (UNLIKELY(state->hadException()))
2951         return false;
2952     impl.setWithScriptStateAttribute(*state, nativeValue);
2953     return true;
2954 }
2955
2956
2957 bool setJSTestObjWithCallWithAndSetterCallWithAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2958 {
2959     JSValue value = JSValue::decode(encodedValue);
2960     UNUSED_PARAM(thisValue);
2961     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2962     if (UNLIKELY(!castedThis)) {
2963         return throwSetterTypeError(*state, "TestObj", "withCallWithAndSetterCallWithAttribute");
2964     }
2965     auto& impl = castedThis->wrapped();
2966     int nativeValue = toInt32(state, value, NormalConversion);
2967     if (UNLIKELY(state->hadException()))
2968         return false;
2969     impl.setWithCallWithAndSetterCallWithAttribute(*state, activeDOMWindow(state), firstDOMWindow(state), nativeValue);
2970     return true;
2971 }
2972
2973
2974 bool setJSTestObjWithScriptExecutionContextAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2975 {
2976     JSValue value = JSValue::decode(encodedValue);
2977     UNUSED_PARAM(thisValue);
2978     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2979     if (UNLIKELY(!castedThis)) {
2980         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAttribute");
2981     }
2982     auto& impl = castedThis->wrapped();
2983     TestObj* nativeValue = JSTestObj::toWrapped(value);
2984     if (UNLIKELY(state->hadException()))
2985         return false;
2986     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
2987     if (!context)
2988         return false;
2989     impl.setWithScriptExecutionContextAttribute(*context, nativeValue);
2990     return true;
2991 }
2992
2993
2994 bool setJSTestObjWithScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
2995 {
2996     JSValue value = JSValue::decode(encodedValue);
2997     UNUSED_PARAM(thisValue);
2998     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
2999     if (UNLIKELY(!castedThis)) {
3000         return throwSetterTypeError(*state, "TestObj", "withScriptStateAttributeRaises");
3001     }
3002     auto& impl = castedThis->wrapped();
3003     TestObj* nativeValue = JSTestObj::toWrapped(value);
3004     if (UNLIKELY(state->hadException()))
3005         return false;
3006     impl.setWithScriptStateAttributeRaises(*state, nativeValue);
3007     return true;
3008 }
3009
3010
3011 bool setJSTestObjWithScriptExecutionContextAttributeRaises(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3012 {
3013     JSValue value = JSValue::decode(encodedValue);
3014     UNUSED_PARAM(thisValue);
3015     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3016     if (UNLIKELY(!castedThis)) {
3017         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAttributeRaises");
3018     }
3019     auto& impl = castedThis->wrapped();
3020     TestObj* nativeValue = JSTestObj::toWrapped(value);
3021     if (UNLIKELY(state->hadException()))
3022         return false;
3023     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3024     if (!context)
3025         return false;
3026     impl.setWithScriptExecutionContextAttributeRaises(*context, nativeValue);
3027     return true;
3028 }
3029
3030
3031 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3032 {
3033     JSValue value = JSValue::decode(encodedValue);
3034     UNUSED_PARAM(thisValue);
3035     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3036     if (UNLIKELY(!castedThis)) {
3037         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttribute");
3038     }
3039     auto& impl = castedThis->wrapped();
3040     TestObj* nativeValue = JSTestObj::toWrapped(value);
3041     if (UNLIKELY(state->hadException()))
3042         return false;
3043     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3044     if (!context)
3045         return false;
3046     impl.setWithScriptExecutionContextAndScriptStateAttribute(*state, *context, nativeValue);
3047     return true;
3048 }
3049
3050
3051 bool setJSTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3052 {
3053     JSValue value = JSValue::decode(encodedValue);
3054     UNUSED_PARAM(thisValue);
3055     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3056     if (UNLIKELY(!castedThis)) {
3057         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateAttributeRaises");
3058     }
3059     auto& impl = castedThis->wrapped();
3060     TestObj* nativeValue = JSTestObj::toWrapped(value);
3061     if (UNLIKELY(state->hadException()))
3062         return false;
3063     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3064     if (!context)
3065         return false;
3066     impl.setWithScriptExecutionContextAndScriptStateAttributeRaises(*state, *context, nativeValue);
3067     return true;
3068 }
3069
3070
3071 bool setJSTestObjWithScriptExecutionContextAndScriptStateWithSpacesAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3072 {
3073     JSValue value = JSValue::decode(encodedValue);
3074     UNUSED_PARAM(thisValue);
3075     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3076     if (UNLIKELY(!castedThis)) {
3077         return throwSetterTypeError(*state, "TestObj", "withScriptExecutionContextAndScriptStateWithSpacesAttribute");
3078     }
3079     auto& impl = castedThis->wrapped();
3080     TestObj* nativeValue = JSTestObj::toWrapped(value);
3081     if (UNLIKELY(state->hadException()))
3082         return false;
3083     auto* context = jsCast<JSDOMGlobalObject*>(state->lexicalGlobalObject())->scriptExecutionContext();
3084     if (!context)
3085         return false;
3086     impl.setWithScriptExecutionContextAndScriptStateWithSpacesAttribute(*state, *context, nativeValue);
3087     return true;
3088 }
3089
3090
3091 bool setJSTestObjWithScriptArgumentsAndCallStackAttribute(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3092 {
3093     JSValue value = JSValue::decode(encodedValue);
3094     UNUSED_PARAM(thisValue);
3095     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3096     if (UNLIKELY(!castedThis)) {
3097         return throwSetterTypeError(*state, "TestObj", "withScriptArgumentsAndCallStackAttribute");
3098     }
3099     auto& impl = castedThis->wrapped();
3100     TestObj* nativeValue = JSTestObj::toWrapped(value);
3101     if (UNLIKELY(state->hadException()))
3102         return false;
3103     impl.setWithScriptArgumentsAndCallStackAttribute(nativeValue);
3104     return true;
3105 }
3106
3107
3108 #if ENABLE(Condition1)
3109 bool setJSTestObjConditionalAttr1(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3110 {
3111     JSValue value = JSValue::decode(encodedValue);
3112     UNUSED_PARAM(thisValue);
3113     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3114     if (UNLIKELY(!castedThis)) {
3115         return throwSetterTypeError(*state, "TestObj", "conditionalAttr1");
3116     }
3117     auto& impl = castedThis->wrapped();
3118     int nativeValue = toInt32(state, value, NormalConversion);
3119     if (UNLIKELY(state->hadException()))
3120         return false;
3121     impl.setConditionalAttr1(nativeValue);
3122     return true;
3123 }
3124
3125 #endif
3126
3127 #if ENABLE(Condition1) && ENABLE(Condition2)
3128 bool setJSTestObjConditionalAttr2(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3129 {
3130     JSValue value = JSValue::decode(encodedValue);
3131     UNUSED_PARAM(thisValue);
3132     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3133     if (UNLIKELY(!castedThis)) {
3134         return throwSetterTypeError(*state, "TestObj", "conditionalAttr2");
3135     }
3136     auto& impl = castedThis->wrapped();
3137     int nativeValue = toInt32(state, value, NormalConversion);
3138     if (UNLIKELY(state->hadException()))
3139         return false;
3140     impl.setConditionalAttr2(nativeValue);
3141     return true;
3142 }
3143
3144 #endif
3145
3146 #if ENABLE(Condition1) || ENABLE(Condition2)
3147 bool setJSTestObjConditionalAttr3(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3148 {
3149     JSValue value = JSValue::decode(encodedValue);
3150     UNUSED_PARAM(thisValue);
3151     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3152     if (UNLIKELY(!castedThis)) {
3153         return throwSetterTypeError(*state, "TestObj", "conditionalAttr3");
3154     }
3155     auto& impl = castedThis->wrapped();
3156     int nativeValue = toInt32(state, value, NormalConversion);
3157     if (UNLIKELY(state->hadException()))
3158         return false;
3159     impl.setConditionalAttr3(nativeValue);
3160     return true;
3161 }
3162
3163 #endif
3164
3165 #if ENABLE(Condition1)
3166 bool setJSTestObjConditionalAttr4Constructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3167 {
3168     JSValue value = JSValue::decode(encodedValue);
3169     UNUSED_PARAM(thisValue);
3170     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3171     if (UNLIKELY(!castedThis)) {
3172         return throwSetterTypeError(*state, "TestObj", "conditionalAttr4");
3173     }
3174     // Shadowing a built-in constructor.
3175     return castedThis->putDirect(state->vm(), Identifier::fromString(state, "conditionalAttr4"), value);
3176 }
3177
3178 #endif
3179
3180 #if ENABLE(Condition1) && ENABLE(Condition2)
3181 bool setJSTestObjConditionalAttr5Constructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
3182 {
3183     JSValue value = JSValue::decode(encodedValue);
3184     UNUSED_PARAM(thisValue);
3185     JSTestObj* castedThis = jsDynamicCast<JSTestObj*>(JSValue::decode(thisValue));
3186     if (UNLIKELY(!castedThis)) {
3187         return throwSetterTypeError(*state, "TestObj", "conditionalAttr5");