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