Changeset 245036 in webkit


Ignore:
Timestamp:
May 7, 2019 2:33:01 PM (5 years ago)
Author:
aestes@apple.com
Message:

run-bindings-tests should test global scope constructor generation
​https://bugs.webkit.org/show_bug.cgi?id=197669

Reviewed by Alex Christensen.

Source/WebCore:

For interfaces that are exposed on a global object, preprocess-idls.pl generates a partial
interface for the global object defining attributes for the interfaces' constructors. Most
interfaces don't specify a global object, so preprocess-idls.pl defaults to DOMWindow.
Since there is no DOMWindow.idl test case, we never generate the code for exposed interface
constructors when running bindings tests. This means that we can't test changes to how these
constructors are generated.

To fix this, teach preprocess-idls.pl to treat 'TestGlobalObject' as the default global
object when running bindings tests. This means that all exposed interface test cases will
generate their constructors as part of JSTestGlobalObject (unless otherwise specified
by the 'Exposed' extended attribute).

  • bindings/scripts/preprocess-idls.pl:

Added --testGlobalContextName and --testGlobalScopeConstructorsFile arguments for use by
run-bindings-tests.

  • bindings/scripts/test/JS/JSTestGlobalObject.cpp:

Updated expected results.

Tools:

  • Scripts/webkitpy/bindings/main.py:

Updated to specify --testGlobalContextName and --testGlobalScopeConstructorsFile when
invoking preprocess-idls.pl.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r245033 r245036  
     12019-05-07  Andy Estes  <aestes@apple.com>
     2
     3        run-bindings-tests should test global scope constructor generation
     4        https://bugs.webkit.org/show_bug.cgi?id=197669
     5
     6        Reviewed by Alex Christensen.
     7
     8        For interfaces that are exposed on a global object, preprocess-idls.pl generates a partial
     9        interface for the global object defining attributes for the interfaces' constructors. Most
     10        interfaces don't specify a global object, so preprocess-idls.pl defaults to DOMWindow.
     11        Since there is no DOMWindow.idl test case, we never generate the code for exposed interface
     12        constructors when running bindings tests. This means that we can't test changes to how these
     13        constructors are generated.
     14
     15        To fix this, teach preprocess-idls.pl to treat 'TestGlobalObject' as the default global
     16        object when running bindings tests. This means that all exposed interface test cases will
     17        generate their constructors as part of JSTestGlobalObject (unless otherwise specified
     18        by the 'Exposed' extended attribute).
     19
     20        * bindings/scripts/preprocess-idls.pl:
     21        Added --testGlobalContextName and --testGlobalScopeConstructorsFile arguments for use by
     22        run-bindings-tests.
     23
     24        * bindings/scripts/test/JS/JSTestGlobalObject.cpp:
     25        Updated expected results.
     26
    1272019-05-07  Youenn Fablet  <youenn@apple.com>
    228

  • trunk/Source/WebCore/bindings/scripts/preprocess-idls.pl

    r242278 r245036  
    3232my $preprocessor;
    3333my $idlFilesList;
     34my $testGlobalContextName;
    3435my $supplementalDependencyFile;
    3536my $windowConstructorsFile;
    … …  
    3940my $workletGlobalScopeConstructorsFile;
    4041my $paintWorkletGlobalScopeConstructorsFile;
     42my $testGlobalScopeConstructorsFile;
    4143my $supplementalMakefileDeps;
    4244
    … …  
    4446           'preprocessor=s' => \$preprocessor,
    4547           'idlFilesList=s' => \$idlFilesList,
     48           'testGlobalContextName=s' => \$testGlobalContextName,
    4649           'supplementalDependencyFile=s' => \$supplementalDependencyFile,
    4750           'windowConstructorsFile=s' => \$windowConstructorsFile,
    … …  
    5154           'workletGlobalScopeConstructorsFile=s' => \$workletGlobalScopeConstructorsFile,
    5255           'paintWorkletGlobalScopeConstructorsFile=s' => \$paintWorkletGlobalScopeConstructorsFile,
     56           'testGlobalScopeConstructorsFile=s' => \$testGlobalScopeConstructorsFile,
    5357           'supplementalMakefileDeps=s' => \$supplementalMakefileDeps);
    5458
    … …  
    6165die('Must specify an output file using --workletGlobalScopeConstructorsFile.') unless defined($workletGlobalScopeConstructorsFile);
    6266die('Must specify an output file using --paintWorkletGlobalScopeConstructorsFile.') unless defined($paintWorkletGlobalScopeConstructorsFile);
     67die('Must specify an output file using --testGlobalScopeConstructorsFile.') unless defined($testGlobalScopeConstructorsFile) || !defined($testGlobalContextName);
    6368die('Must specify the file listing all IDLs using --idlFilesList.') unless defined($idlFilesList);
    6469
    … …  
    9196my $workletGlobalScopeConstructorsCode = "";
    9297my $paintWorkletGlobalScopeConstructorsCode = "";
     98my $testGlobalScopeConstructorsCode = "";
    9399
    94100# Get rid of duplicates in idlFiles array.
    … …  
    141147    if (shouldExposeInterface($extendedAttributes)) {
    142148        if (!isCallbackInterfaceFromIDL($idlFileContents) || interfaceHasConstantAttribute($idlFileContents)) {
    143             my $exposedAttribute = $extendedAttributes->{"Exposed"} || "Window";
     149            my $exposedAttribute = $extendedAttributes->{"Exposed"} || $testGlobalContextName || "Window";
    144150            $exposedAttribute = substr($exposedAttribute, 1, -1) if substr($exposedAttribute, 0, 1) eq "(";
    145151            my @globalContexts = split(",", $exposedAttribute);
    … …  
    158164                } elsif ($globalContext eq "PaintWorklet") {
    159165                    $paintWorkletGlobalScopeConstructorsCode .= $attributeCode;
     166                } elsif ($globalContext eq $testGlobalContextName) {
     167                    $testGlobalScopeConstructorsCode .= $attributeCode;
    160168                } else {
    161169                    die "Unsupported global context '$globalContext' used in [Exposed] at $idlFile";
    … …  
    174182GeneratePartialInterface("WorkletGlobalScope", $workletGlobalScopeConstructorsCode, $workletGlobalScopeConstructorsFile);
    175183GeneratePartialInterface("PaintWorkletGlobalScope", $paintWorkletGlobalScopeConstructorsCode, $paintWorkletGlobalScopeConstructorsFile);
     184GeneratePartialInterface($testGlobalContextName, $testGlobalScopeConstructorsCode, $testGlobalScopeConstructorsFile) if defined($testGlobalContextName);
    176185
    177186# Resolves partial interfaces and implements dependencies.

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestGlobalObject.cpp

    r240557 r245036  
    3333#include "JSDOMOperationReturningPromise.h"
    3434#include "JSDOMWrapperCache.h"
     35#include "JSTestCEReactions.h"
     36#include "JSTestCEReactionsStringifier.h"
     37#include "JSTestCallTracer.h"
     38#include "JSTestClassWithJSBuiltinConstructor.h"
     39#include "JSTestDOMJIT.h"
     40#include "JSTestDomainSecurity.h"
     41#include "JSTestEnabledBySetting.h"
     42#include "JSTestEventConstructor.h"
     43#include "JSTestEventTarget.h"
     44#include "JSTestException.h"
     45#include "JSTestGenerateIsReachable.h"
     46#include "JSTestGlobalObject.h"
     47#include "JSTestIndexedSetterNoIdentifier.h"
     48#include "JSTestIndexedSetterThrowingException.h"
     49#include "JSTestIndexedSetterWithIdentifier.h"
     50#include "JSTestInterfaceLeadingUnderscore.h"
     51#include "JSTestIterable.h"
     52#include "JSTestJSBuiltinConstructor.h"
     53#include "JSTestMapLike.h"
     54#include "JSTestMediaQueryListListener.h"
     55#include "JSTestNamedAndIndexedSetterNoIdentifier.h"
     56#include "JSTestNamedAndIndexedSetterThrowingException.h"
     57#include "JSTestNamedAndIndexedSetterWithIdentifier.h"
     58#include "JSTestNamedConstructor.h"
     59#include "JSTestNamedConstructorNamed.h"
     60#include "JSTestNamedDeleterNoIdentifier.h"
     61#include "JSTestNamedDeleterThrowingException.h"
     62#include "JSTestNamedDeleterWithIdentifier.h"
     63#include "JSTestNamedDeleterWithIndexedGetter.h"
     64#include "JSTestNamedGetterCallWith.h"
     65#include "JSTestNamedGetterNoIdentifier.h"
     66#include "JSTestNamedGetterWithIdentifier.h"
     67#include "JSTestNamedSetterNoIdentifier.h"
     68#include "JSTestNamedSetterThrowingException.h"
     69#include "JSTestNamedSetterWithIdentifier.h"
     70#include "JSTestNamedSetterWithIndexedGetter.h"
     71#include "JSTestNamedSetterWithIndexedGetterAndSetter.h"
     72#include "JSTestNamedSetterWithOverrideBuiltins.h"
     73#include "JSTestNamedSetterWithUnforgableProperties.h"
     74#include "JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.h"
     75#include "JSTestOverloadedConstructors.h"
     76#include "JSTestOverloadedConstructorsWithSequence.h"
     77#include "JSTestOverrideBuiltins.h"
     78#include "JSTestPluginInterface.h"
     79#include "JSTestReadOnlyMapLike.h"
     80#include "JSTestReportExtraMemoryCost.h"
     81#include "JSTestSerialization.h"
     82#include "JSTestSerializationIndirectInheritance.h"
     83#include "JSTestSerializationInherit.h"
     84#include "JSTestSerializationInheritFinal.h"
     85#include "JSTestStringifier.h"
     86#include "JSTestStringifierAnonymousOperation.h"
     87#include "JSTestStringifierNamedOperation.h"
     88#include "JSTestStringifierOperationImplementedAs.h"
     89#include "JSTestStringifierOperationNamedToString.h"
     90#include "JSTestStringifierReadOnlyAttribute.h"
     91#include "JSTestStringifierReadWriteAttribute.h"
     92#include "JSTestTypedefs.h"
    3593#include "RuntimeEnabledFeatures.h"
    3694#include "ScriptExecutionContext.h"
    … …  
    43101#include <wtf/URL.h>
    44102
     103#if ENABLE(Condition1) || ENABLE(Condition2)
     104#include "JSTestInterface.h"
     105#include "JSTestSerializedScriptValueInterface.h"
     106#endif
     107
     108#if ENABLE(TEST_CONDITIONAL)
     109#include "JSTestCallbackInterface.h"
     110#endif
     111
    45112#if ENABLE(TEST_FEATURE)
    46113#include "TestGlobalObjectBuiltins.h"
    … …  
    88155bool setJSTestGlobalObjectEnabledAtRuntimeAttribute(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
    89156#endif
     157JSC::EncodedJSValue jsTestGlobalObjectTestCEReactionsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     158bool setJSTestGlobalObjectTestCEReactionsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     159JSC::EncodedJSValue jsTestGlobalObjectTestCEReactionsStringifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     160bool setJSTestGlobalObjectTestCEReactionsStringifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     161JSC::EncodedJSValue jsTestGlobalObjectTestCallTracerConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     162bool setJSTestGlobalObjectTestCallTracerConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     163#if ENABLE(TEST_CONDITIONAL)
     164JSC::EncodedJSValue jsTestGlobalObjectTestCallbackInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     165bool setJSTestGlobalObjectTestCallbackInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     166#endif
     167JSC::EncodedJSValue jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     168bool setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     169JSC::EncodedJSValue jsTestGlobalObjectTestDOMJITConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     170bool setJSTestGlobalObjectTestDOMJITConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     171JSC::EncodedJSValue jsTestGlobalObjectTestDomainSecurityConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     172bool setJSTestGlobalObjectTestDomainSecurityConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     173JSC::EncodedJSValue jsTestGlobalObjectTestEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     174bool setJSTestGlobalObjectTestEnabledBySettingConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     175JSC::EncodedJSValue jsTestGlobalObjectTestEventConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     176bool setJSTestGlobalObjectTestEventConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     177JSC::EncodedJSValue jsTestGlobalObjectTestEventTargetConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     178bool setJSTestGlobalObjectTestEventTargetConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     179JSC::EncodedJSValue jsTestGlobalObjectTestExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     180bool setJSTestGlobalObjectTestExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     181JSC::EncodedJSValue jsTestGlobalObjectTestGenerateIsReachableConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     182bool setJSTestGlobalObjectTestGenerateIsReachableConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     183JSC::EncodedJSValue jsTestGlobalObjectTestGlobalObjectConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     184bool setJSTestGlobalObjectTestGlobalObjectConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     185JSC::EncodedJSValue jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     186bool setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     187JSC::EncodedJSValue jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     188bool setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     189JSC::EncodedJSValue jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     190bool setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     191#if ENABLE(Condition1) || ENABLE(Condition2)
     192JSC::EncodedJSValue jsTestGlobalObjectTestInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     193bool setJSTestGlobalObjectTestInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     194#endif
     195JSC::EncodedJSValue jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     196bool setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     197JSC::EncodedJSValue jsTestGlobalObjectTestIterableConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     198bool setJSTestGlobalObjectTestIterableConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     199JSC::EncodedJSValue jsTestGlobalObjectTestJSBuiltinConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     200bool setJSTestGlobalObjectTestJSBuiltinConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     201JSC::EncodedJSValue jsTestGlobalObjectTestMapLikeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     202bool setJSTestGlobalObjectTestMapLikeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     203JSC::EncodedJSValue jsTestGlobalObjectTestMediaQueryListListenerConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     204bool setJSTestGlobalObjectTestMediaQueryListListenerConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     205JSC::EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     206bool setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     207JSC::EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     208bool setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     209JSC::EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     210bool setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     211JSC::EncodedJSValue jsTestGlobalObjectTestNamedConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     212bool setJSTestGlobalObjectTestNamedConstructorConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     213JSC::EncodedJSValue jsTestGlobalObjectAudioConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     214bool setJSTestGlobalObjectAudioConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     215JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     216bool setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     217JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     218bool setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     219JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     220bool setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     221JSC::EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     222bool setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     223JSC::EncodedJSValue jsTestGlobalObjectTestNamedGetterCallWithConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     224bool setJSTestGlobalObjectTestNamedGetterCallWithConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     225JSC::EncodedJSValue jsTestGlobalObjectTestNamedGetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     226bool setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     227JSC::EncodedJSValue jsTestGlobalObjectTestNamedGetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     228bool setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     229JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     230bool setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     231JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     232bool setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     233JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     234bool setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     235JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     236bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     237JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     238bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     239JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     240bool setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     241JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     242bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     243JSC::EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     244bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     245JSC::EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     246bool setJSTestGlobalObjectTestOverloadedConstructorsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     247JSC::EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     248bool setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     249JSC::EncodedJSValue jsTestGlobalObjectTestOverrideBuiltinsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     250bool setJSTestGlobalObjectTestOverrideBuiltinsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     251JSC::EncodedJSValue jsTestGlobalObjectTestPluginInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     252bool setJSTestGlobalObjectTestPluginInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     253JSC::EncodedJSValue jsTestGlobalObjectTestReadOnlyMapLikeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     254bool setJSTestGlobalObjectTestReadOnlyMapLikeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     255JSC::EncodedJSValue jsTestGlobalObjectTestReportExtraMemoryCostConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     256bool setJSTestGlobalObjectTestReportExtraMemoryCostConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     257JSC::EncodedJSValue jsTestGlobalObjectTestSerializationConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     258bool setJSTestGlobalObjectTestSerializationConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     259JSC::EncodedJSValue jsTestGlobalObjectTestSerializationIndirectInheritanceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     260bool setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     261JSC::EncodedJSValue jsTestGlobalObjectTestSerializationInheritConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     262bool setJSTestGlobalObjectTestSerializationInheritConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     263JSC::EncodedJSValue jsTestGlobalObjectTestSerializationInheritFinalConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     264bool setJSTestGlobalObjectTestSerializationInheritFinalConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     265#if ENABLE(Condition1) || ENABLE(Condition2)
     266JSC::EncodedJSValue jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     267bool setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     268#endif
     269JSC::EncodedJSValue jsTestGlobalObjectTestStringifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     270bool setJSTestGlobalObjectTestStringifierConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     271JSC::EncodedJSValue jsTestGlobalObjectTestStringifierAnonymousOperationConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     272bool setJSTestGlobalObjectTestStringifierAnonymousOperationConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     273JSC::EncodedJSValue jsTestGlobalObjectTestStringifierNamedOperationConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     274bool setJSTestGlobalObjectTestStringifierNamedOperationConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     275JSC::EncodedJSValue jsTestGlobalObjectTestStringifierOperationImplementedAsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     276bool setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     277JSC::EncodedJSValue jsTestGlobalObjectTestStringifierOperationNamedToStringConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     278bool setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     279JSC::EncodedJSValue jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     280bool setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     281JSC::EncodedJSValue jsTestGlobalObjectTestStringifierReadWriteAttributeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     282bool setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
     283JSC::EncodedJSValue jsTestGlobalObjectTestTypedefsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::PropertyName);
     284bool setJSTestGlobalObjectTestTypedefsConstructor(JSC::ExecState*, JSC::EncodedJSValue, JSC::EncodedJSValue);
    90285
    91286using JSTestGlobalObjectConstructor = JSDOMConstructorNotConstructable<JSTestGlobalObject>;
    … …  
    93288/* Hash table */
    94289
    95 static const struct CompactHashIndex JSTestGlobalObjectTableIndex[16] = {
    96     { -1, -1 },
     290static const struct CompactHashIndex JSTestGlobalObjectTableIndex[266] = {
     291    { -1, -1 },
     292    { 37, -1 },
     293    { -1, -1 },
     294    { 0, -1 },
     295    { 4, 262 },
     296    { 41, -1 },
     297    { -1, -1 },
     298    { -1, -1 },
     299    { -1, -1 },
     300    { -1, -1 },
     301    { -1, -1 },
     302    { -1, -1 },
     303    { -1, -1 },
     304    { 50, -1 },
     305    { -1, -1 },
     306    { -1, -1 },
     307    { -1, -1 },
     308    { 19, -1 },
     309    { -1, -1 },
     310    { -1, -1 },
     311    { -1, -1 },
     312    { 61, -1 },
     313    { -1, -1 },
     314    { -1, -1 },
     315    { -1, -1 },
     316    { -1, -1 },
     317    { -1, -1 },
     318    { -1, -1 },
     319    { -1, -1 },
     320    { -1, -1 },
     321    { -1, -1 },
     322    { -1, -1 },
     323    { -1, -1 },
     324    { -1, -1 },
     325    { -1, -1 },
     326    { 31, -1 },
     327    { -1, -1 },
     328    { -1, -1 },
     329    { -1, -1 },
     330    { -1, -1 },
     331    { -1, -1 },
     332    { 64, -1 },
     333    { 9, 258 },
     334    { -1, -1 },
     335    { -1, -1 },
     336    { -1, -1 },
     337    { -1, -1 },
     338    { -1, -1 },
     339    { -1, -1 },
     340    { -1, -1 },
     341    { 35, -1 },
     342    { 16, 263 },
     343    { 6, -1 },
     344    { -1, -1 },
     345    { -1, -1 },
     346    { -1, -1 },
     347    { -1, -1 },
     348    { -1, -1 },
     349    { -1, -1 },
     350    { -1, -1 },
     351    { -1, -1 },
     352    { -1, -1 },
     353    { -1, -1 },
     354    { 33, -1 },
     355    { -1, -1 },
     356    { -1, -1 },
     357    { -1, -1 },
     358    { -1, -1 },
     359    { -1, -1 },
     360    { -1, -1 },
     361    { 18, 264 },
     362    { -1, -1 },
     363    { -1, -1 },
     364    { -1, -1 },
     365    { -1, -1 },
     366    { -1, -1 },
     367    { 5, -1 },
     368    { -1, -1 },
     369    { -1, -1 },
     370    { -1, -1 },
     371    { -1, -1 },
     372    { -1, -1 },
     373    { -1, -1 },
     374    { -1, -1 },
     375    { -1, -1 },
     376    { -1, -1 },
     377    { -1, -1 },
     378    { -1, -1 },
     379    { -1, -1 },
     380    { -1, -1 },
     381    { -1, -1 },
     382    { -1, -1 },
     383    { 20, 256 },
     384    { -1, -1 },
     385    { 56, -1 },
     386    { 15, -1 },
     387    { -1, -1 },
     388    { -1, -1 },
     389    { 43, -1 },
     390    { 14, -1 },
     391    { -1, -1 },
     392    { -1, -1 },
     393    { -1, -1 },
     394    { -1, -1 },
     395    { 32, -1 },
     396    { -1, -1 },
     397    { -1, -1 },
     398    { -1, -1 },
     399    { -1, -1 },
     400    { -1, -1 },
     401    { -1, -1 },
     402    { 47, -1 },
     403    { 21, -1 },
    97404    { -1, -1 },
    98405    { 2, -1 },
    99     { 0, -1 },
    100     { -1, -1 },
    101     { -1, -1 },
    102     { -1, -1 },
    103     { -1, -1 },
    104     { -1, -1 },
     406    { 34, -1 },
     407    { -1, -1 },
     408    { -1, -1 },
     409    { -1, -1 },
     410    { 17, -1 },
     411    { -1, -1 },
     412    { -1, -1 },
     413    { -1, -1 },
     414    { -1, -1 },
     415    { -1, -1 },
     416    { 54, -1 },
     417    { -1, -1 },
     418    { -1, -1 },
     419    { -1, -1 },
     420    { -1, -1 },
     421    { -1, -1 },
     422    { 28, -1 },
     423    { 24, -1 },
     424    { -1, -1 },
     425    { 39, -1 },
     426    { -1, -1 },
     427    { -1, -1 },
     428    { -1, -1 },
     429    { -1, -1 },
     430    { -1, -1 },
     431    { -1, -1 },
     432    { -1, -1 },
     433    { 10, -1 },
     434    { -1, -1 },
     435    { -1, -1 },
     436    { -1, -1 },
     437    { -1, -1 },
     438    { -1, -1 },
     439    { -1, -1 },
     440    { -1, -1 },
     441    { -1, -1 },
     442    { -1, -1 },
     443    { -1, -1 },
     444    { -1, -1 },
     445    { -1, -1 },
     446    { -1, -1 },
     447    { -1, -1 },
     448    { -1, -1 },
     449    { 62, -1 },
     450    { -1, -1 },
     451    { -1, -1 },
     452    { -1, -1 },
     453    { 29, -1 },
     454    { 26, 261 },
     455    { -1, -1 },
     456    { -1, -1 },
     457    { -1, -1 },
     458    { -1, -1 },
     459    { -1, -1 },
     460    { -1, -1 },
     461    { -1, -1 },
     462    { -1, -1 },
     463    { -1, -1 },
     464    { 12, 257 },
     465    { -1, -1 },
     466    { 57, -1 },
     467    { -1, -1 },
     468    { -1, -1 },
     469    { -1, -1 },
     470    { -1, -1 },
     471    { -1, -1 },
     472    { -1, -1 },
     473    { -1, -1 },
     474    { -1, -1 },
     475    { 30, 265 },
     476    { -1, -1 },
     477    { 13, -1 },
     478    { -1, -1 },
     479    { 60, -1 },
     480    { -1, -1 },
     481    { -1, -1 },
     482    { -1, -1 },
     483    { -1, -1 },
     484    { -1, -1 },
     485    { 45, -1 },
     486    { -1, -1 },
     487    { -1, -1 },
     488    { -1, -1 },
     489    { -1, -1 },
     490    { -1, -1 },
     491    { -1, -1 },
     492    { -1, -1 },
     493    { -1, -1 },
     494    { -1, -1 },
     495    { -1, -1 },
     496    { -1, -1 },
     497    { -1, -1 },
     498    { 52, -1 },
     499    { -1, -1 },
     500    { -1, -1 },
     501    { -1, -1 },
     502    { -1, -1 },
     503    { -1, -1 },
     504    { -1, -1 },
     505    { -1, -1 },
     506    { -1, -1 },
     507    { -1, -1 },
     508    { -1, -1 },
     509    { -1, -1 },
     510    { -1, -1 },
     511    { -1, -1 },
     512    { -1, -1 },
     513    { 1, -1 },
     514    { -1, -1 },
     515    { 8, -1 },
     516    { -1, -1 },
     517    { -1, -1 },
     518    { -1, -1 },
     519    { -1, -1 },
     520    { 46, -1 },
     521    { 7, 260 },
     522    { -1, -1 },
     523    { 58, -1 },
     524    { -1, -1 },
     525    { 44, -1 },
     526    { -1, -1 },
     527    { -1, -1 },
     528    { -1, -1 },
     529    { -1, -1 },
     530    { 11, -1 },
     531    { -1, -1 },
     532    { 22, -1 },
     533    { -1, -1 },
     534    { -1, -1 },
     535    { 25, -1 },
     536    { -1, -1 },
     537    { -1, -1 },
     538    { 42, -1 },
    105539    { 3, -1 },
    106     { -1, -1 },
    107     { -1, -1 },
    108     { -1, -1 },
    109     { -1, -1 },
    110     { 1, -1 },
    111     { -1, -1 },
     540    { 48, -1 },
     541    { -1, -1 },
     542    { 49, -1 },
     543    { -1, -1 },
     544    { -1, -1 },
     545    { -1, -1 },
     546    { -1, -1 },
     547    { 23, 259 },
     548    { 27, -1 },
     549    { 36, -1 },
     550    { 38, -1 },
     551    { 40, -1 },
     552    { 51, -1 },
     553    { 53, -1 },
     554    { 55, -1 },
     555    { 59, -1 },
     556    { 63, -1 },
    112557};
    113558
    … …  
    122567    { 0, 0, NoIntrinsic, { 0, 0 } },
    123568#endif
     569    { "TestCEReactions", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCEReactionsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCEReactionsConstructor) } },
     570    { "TestCEReactionsStringifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCEReactionsStringifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCEReactionsStringifierConstructor) } },
     571    { "TestCallTracer", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCallTracerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCallTracerConstructor) } },
     572#if ENABLE(TEST_CONDITIONAL)
     573    { "TestCallbackInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestCallbackInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestCallbackInterfaceConstructor) } },
     574#else
     575    { 0, 0, NoIntrinsic, { 0, 0 } },
     576#endif
     577    { "TestClassWithJSBuiltinConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor) } },
     578    { "TestDOMJIT", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestDOMJITConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestDOMJITConstructor) } },
     579    { "TestDomainSecurity", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestDomainSecurityConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestDomainSecurityConstructor) } },
     580    { "TestEnabledBySetting", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestEnabledBySettingConstructor) } },
     581    { "TestEventConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestEventConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestEventConstructorConstructor) } },
     582    { "TestEventTarget", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestEventTargetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestEventTargetConstructor) } },
     583    { "TestException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestExceptionConstructor) } },
     584    { "TestGenerateIsReachable", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestGenerateIsReachableConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestGenerateIsReachableConstructor) } },
     585    { "TestGlobalObject", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestGlobalObjectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestGlobalObjectConstructor) } },
     586    { "TestIndexedSetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructor) } },
     587    { "TestIndexedSetterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor) } },
     588    { "TestIndexedSetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructor) } },
     589#if ENABLE(Condition1) || ENABLE(Condition2)
     590    { "TestInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestInterfaceConstructor) } },
     591#else
     592    { 0, 0, NoIntrinsic, { 0, 0 } },
     593#endif
     594    { "TestInterfaceLeadingUnderscore", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor) } },
     595    { "TestIterable", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestIterableConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestIterableConstructor) } },
     596    { "TestJSBuiltinConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestJSBuiltinConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestJSBuiltinConstructorConstructor) } },
     597    { "TestMapLike", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestMapLikeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestMapLikeConstructor) } },
     598    { "TestMediaQueryListListener", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestMediaQueryListListenerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestMediaQueryListListenerConstructor) } },
     599    { "TestNamedAndIndexedSetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor) } },
     600    { "TestNamedAndIndexedSetterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor) } },
     601    { "TestNamedAndIndexedSetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor) } },
     602    { "TestNamedConstructor", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedConstructorConstructor) } },
     603    { "Audio", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectAudioConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectAudioConstructor) } },
     604    { "TestNamedDeleterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructor) } },
     605    { "TestNamedDeleterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor) } },
     606    { "TestNamedDeleterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructor) } },
     607    { "TestNamedDeleterWithIndexedGetter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor) } },
     608    { "TestNamedGetterCallWith", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedGetterCallWithConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedGetterCallWithConstructor) } },
     609    { "TestNamedGetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedGetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructor) } },
     610    { "TestNamedGetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedGetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructor) } },
     611    { "TestNamedSetterNoIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterNoIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructor) } },
     612    { "TestNamedSetterThrowingException", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructor) } },
     613    { "TestNamedSetterWithIdentifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithIdentifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructor) } },
     614    { "TestNamedSetterWithIndexedGetter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor) } },
     615    { "TestNamedSetterWithIndexedGetterAndSetter", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor) } },
     616    { "TestNamedSetterWithOverrideBuiltins", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor) } },
     617    { "TestNamedSetterWithUnforgableProperties", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor) } },
     618    { "TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor) } },
     619    { "TestOverloadedConstructors", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestOverloadedConstructorsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestOverloadedConstructorsConstructor) } },
     620    { "TestOverloadedConstructorsWithSequence", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor) } },
     621    { "TestOverrideBuiltins", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestOverrideBuiltinsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestOverrideBuiltinsConstructor) } },
     622    { "TestPluginInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestPluginInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestPluginInterfaceConstructor) } },
     623    { "TestReadOnlyMapLike", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestReadOnlyMapLikeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestReadOnlyMapLikeConstructor) } },
     624    { "TestReportExtraMemoryCost", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestReportExtraMemoryCostConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestReportExtraMemoryCostConstructor) } },
     625    { "TestSerialization", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationConstructor) } },
     626    { "TestSerializationIndirectInheritance", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationIndirectInheritanceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructor) } },
     627    { "TestSerializationInherit", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationInheritConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationInheritConstructor) } },
     628    { "TestSerializationInheritFinal", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializationInheritFinalConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializationInheritFinalConstructor) } },
     629#if ENABLE(Condition1) || ENABLE(Condition2)
     630    { "TestSerializedScriptValueInterface", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructor) } },
     631#else
     632    { 0, 0, NoIntrinsic, { 0, 0 } },
     633#endif
     634    { "TestStringifier", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierConstructor) } },
     635    { "TestStringifierAnonymousOperation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierAnonymousOperationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierAnonymousOperationConstructor) } },
     636    { "TestStringifierNamedOperation", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierNamedOperationConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierNamedOperationConstructor) } },
     637    { "TestStringifierOperationImplementedAs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierOperationImplementedAsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructor) } },
     638    { "TestStringifierOperationNamedToString", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierOperationNamedToStringConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructor) } },
     639    { "TestStringifierReadOnlyAttribute", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructor) } },
     640    { "TestStringifierReadWriteAttribute", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestStringifierReadWriteAttributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructor) } },
     641    { "TestTypedefs", static_cast<unsigned>(JSC::PropertyAttribute::DontEnum), NoIntrinsic, { (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGlobalObjectTestTypedefsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestGlobalObjectTestTypedefsConstructor) } },
    124642    { "regularOperation", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestGlobalObjectInstanceFunctionRegularOperation), (intptr_t) (1) } },
    125643};
    126644
    127 static const HashTable JSTestGlobalObjectTable = { 4, 15, true, JSTestGlobalObject::info(), JSTestGlobalObjectTableValues, JSTestGlobalObjectTableIndex };
     645static const HashTable JSTestGlobalObjectTable = { 65, 255, true, JSTestGlobalObject::info(), JSTestGlobalObjectTableValues, JSTestGlobalObjectTableIndex };
    128646/* Hash table for constructor */
    129647
    … …  
    401919#endif
    402920
     921static inline JSValue jsTestGlobalObjectTestCEReactionsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     922{
     923    UNUSED_PARAM(throwScope);
     924    UNUSED_PARAM(state);
     925    return JSTestCEReactions::getConstructor(state.vm(), thisObject.globalObject());
     926}
     927
     928EncodedJSValue jsTestGlobalObjectTestCEReactionsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     929{
     930    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCEReactionsConstructorGetter>(*state, thisValue, "TestCEReactions");
     931}
     932
     933static inline bool setJSTestGlobalObjectTestCEReactionsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     934{
     935    UNUSED_PARAM(throwScope);
     936    // Shadowing a built-in constructor.
     937    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestCEReactions"), strlen("TestCEReactions")), value);
     938}
     939
     940bool setJSTestGlobalObjectTestCEReactionsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     941{
     942    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCEReactionsConstructorSetter>(*state, thisValue, encodedValue, "TestCEReactions");
     943}
     944
     945static inline JSValue jsTestGlobalObjectTestCEReactionsStringifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     946{
     947    UNUSED_PARAM(throwScope);
     948    UNUSED_PARAM(state);
     949    return JSTestCEReactionsStringifier::getConstructor(state.vm(), thisObject.globalObject());
     950}
     951
     952EncodedJSValue jsTestGlobalObjectTestCEReactionsStringifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     953{
     954    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCEReactionsStringifierConstructorGetter>(*state, thisValue, "TestCEReactionsStringifier");
     955}
     956
     957static inline bool setJSTestGlobalObjectTestCEReactionsStringifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     958{
     959    UNUSED_PARAM(throwScope);
     960    // Shadowing a built-in constructor.
     961    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestCEReactionsStringifier"), strlen("TestCEReactionsStringifier")), value);
     962}
     963
     964bool setJSTestGlobalObjectTestCEReactionsStringifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     965{
     966    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCEReactionsStringifierConstructorSetter>(*state, thisValue, encodedValue, "TestCEReactionsStringifier");
     967}
     968
     969static inline JSValue jsTestGlobalObjectTestCallTracerConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     970{
     971    UNUSED_PARAM(throwScope);
     972    UNUSED_PARAM(state);
     973    return JSTestCallTracer::getConstructor(state.vm(), thisObject.globalObject());
     974}
     975
     976EncodedJSValue jsTestGlobalObjectTestCallTracerConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     977{
     978    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCallTracerConstructorGetter>(*state, thisValue, "TestCallTracer");
     979}
     980
     981static inline bool setJSTestGlobalObjectTestCallTracerConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     982{
     983    UNUSED_PARAM(throwScope);
     984    // Shadowing a built-in constructor.
     985    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestCallTracer"), strlen("TestCallTracer")), value);
     986}
     987
     988bool setJSTestGlobalObjectTestCallTracerConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     989{
     990    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCallTracerConstructorSetter>(*state, thisValue, encodedValue, "TestCallTracer");
     991}
     992
     993#if ENABLE(TEST_CONDITIONAL)
     994static inline JSValue jsTestGlobalObjectTestCallbackInterfaceConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     995{
     996    UNUSED_PARAM(throwScope);
     997    UNUSED_PARAM(state);
     998    return JSTestCallbackInterface::getConstructor(state.vm(), thisObject.globalObject());
     999}
     1000
     1001EncodedJSValue jsTestGlobalObjectTestCallbackInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1002{
     1003    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestCallbackInterfaceConstructorGetter>(*state, thisValue, "TestCallbackInterface");
     1004}
     1005
     1006#endif
     1007
     1008#if ENABLE(TEST_CONDITIONAL)
     1009static inline bool setJSTestGlobalObjectTestCallbackInterfaceConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1010{
     1011    UNUSED_PARAM(throwScope);
     1012    // Shadowing a built-in constructor.
     1013    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestCallbackInterface"), strlen("TestCallbackInterface")), value);
     1014}
     1015
     1016bool setJSTestGlobalObjectTestCallbackInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1017{
     1018    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestCallbackInterfaceConstructorSetter>(*state, thisValue, encodedValue, "TestCallbackInterface");
     1019}
     1020
     1021#endif
     1022
     1023static inline JSValue jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1024{
     1025    UNUSED_PARAM(throwScope);
     1026    UNUSED_PARAM(state);
     1027    return JSTestClassWithJSBuiltinConstructor::getConstructor(state.vm(), thisObject.globalObject());
     1028}
     1029
     1030EncodedJSValue jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1031{
     1032    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorGetter>(*state, thisValue, "TestClassWithJSBuiltinConstructor");
     1033}
     1034
     1035static inline bool setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1036{
     1037    UNUSED_PARAM(throwScope);
     1038    // Shadowing a built-in constructor.
     1039    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestClassWithJSBuiltinConstructor"), strlen("TestClassWithJSBuiltinConstructor")), value);
     1040}
     1041
     1042bool setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1043{
     1044    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestClassWithJSBuiltinConstructorConstructorSetter>(*state, thisValue, encodedValue, "TestClassWithJSBuiltinConstructor");
     1045}
     1046
     1047static inline JSValue jsTestGlobalObjectTestDOMJITConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1048{
     1049    UNUSED_PARAM(throwScope);
     1050    UNUSED_PARAM(state);
     1051    return JSTestDOMJIT::getConstructor(state.vm(), thisObject.globalObject());
     1052}
     1053
     1054EncodedJSValue jsTestGlobalObjectTestDOMJITConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1055{
     1056    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestDOMJITConstructorGetter>(*state, thisValue, "TestDOMJIT");
     1057}
     1058
     1059static inline bool setJSTestGlobalObjectTestDOMJITConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1060{
     1061    UNUSED_PARAM(throwScope);
     1062    // Shadowing a built-in constructor.
     1063    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestDOMJIT"), strlen("TestDOMJIT")), value);
     1064}
     1065
     1066bool setJSTestGlobalObjectTestDOMJITConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1067{
     1068    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestDOMJITConstructorSetter>(*state, thisValue, encodedValue, "TestDOMJIT");
     1069}
     1070
     1071static inline JSValue jsTestGlobalObjectTestDomainSecurityConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1072{
     1073    UNUSED_PARAM(throwScope);
     1074    UNUSED_PARAM(state);
     1075    return JSTestDomainSecurity::getConstructor(state.vm(), thisObject.globalObject());
     1076}
     1077
     1078EncodedJSValue jsTestGlobalObjectTestDomainSecurityConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1079{
     1080    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestDomainSecurityConstructorGetter>(*state, thisValue, "TestDomainSecurity");
     1081}
     1082
     1083static inline bool setJSTestGlobalObjectTestDomainSecurityConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1084{
     1085    UNUSED_PARAM(throwScope);
     1086    // Shadowing a built-in constructor.
     1087    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestDomainSecurity"), strlen("TestDomainSecurity")), value);
     1088}
     1089
     1090bool setJSTestGlobalObjectTestDomainSecurityConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1091{
     1092    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestDomainSecurityConstructorSetter>(*state, thisValue, encodedValue, "TestDomainSecurity");
     1093}
     1094
     1095static inline JSValue jsTestGlobalObjectTestEnabledBySettingConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1096{
     1097    UNUSED_PARAM(throwScope);
     1098    UNUSED_PARAM(state);
     1099    return JSTestEnabledBySetting::getConstructor(state.vm(), thisObject.globalObject());
     1100}
     1101
     1102EncodedJSValue jsTestGlobalObjectTestEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1103{
     1104    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEnabledBySettingConstructorGetter>(*state, thisValue, "TestEnabledBySetting");
     1105}
     1106
     1107static inline bool setJSTestGlobalObjectTestEnabledBySettingConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1108{
     1109    UNUSED_PARAM(throwScope);
     1110    // Shadowing a built-in constructor.
     1111    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestEnabledBySetting"), strlen("TestEnabledBySetting")), value);
     1112}
     1113
     1114bool setJSTestGlobalObjectTestEnabledBySettingConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1115{
     1116    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEnabledBySettingConstructorSetter>(*state, thisValue, encodedValue, "TestEnabledBySetting");
     1117}
     1118
     1119static inline JSValue jsTestGlobalObjectTestEventConstructorConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1120{
     1121    UNUSED_PARAM(throwScope);
     1122    UNUSED_PARAM(state);
     1123    return JSTestEventConstructor::getConstructor(state.vm(), thisObject.globalObject());
     1124}
     1125
     1126EncodedJSValue jsTestGlobalObjectTestEventConstructorConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1127{
     1128    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEventConstructorConstructorGetter>(*state, thisValue, "TestEventConstructor");
     1129}
     1130
     1131static inline bool setJSTestGlobalObjectTestEventConstructorConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1132{
     1133    UNUSED_PARAM(throwScope);
     1134    // Shadowing a built-in constructor.
     1135    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestEventConstructor"), strlen("TestEventConstructor")), value);
     1136}
     1137
     1138bool setJSTestGlobalObjectTestEventConstructorConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1139{
     1140    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEventConstructorConstructorSetter>(*state, thisValue, encodedValue, "TestEventConstructor");
     1141}
     1142
     1143static inline JSValue jsTestGlobalObjectTestEventTargetConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1144{
     1145    UNUSED_PARAM(throwScope);
     1146    UNUSED_PARAM(state);
     1147    return JSTestEventTarget::getConstructor(state.vm(), thisObject.globalObject());
     1148}
     1149
     1150EncodedJSValue jsTestGlobalObjectTestEventTargetConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1151{
     1152    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestEventTargetConstructorGetter>(*state, thisValue, "TestEventTarget");
     1153}
     1154
     1155static inline bool setJSTestGlobalObjectTestEventTargetConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1156{
     1157    UNUSED_PARAM(throwScope);
     1158    // Shadowing a built-in constructor.
     1159    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestEventTarget"), strlen("TestEventTarget")), value);
     1160}
     1161
     1162bool setJSTestGlobalObjectTestEventTargetConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1163{
     1164    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestEventTargetConstructorSetter>(*state, thisValue, encodedValue, "TestEventTarget");
     1165}
     1166
     1167static inline JSValue jsTestGlobalObjectTestExceptionConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1168{
     1169    UNUSED_PARAM(throwScope);
     1170    UNUSED_PARAM(state);
     1171    return JSTestException::getConstructor(state.vm(), thisObject.globalObject());
     1172}
     1173
     1174EncodedJSValue jsTestGlobalObjectTestExceptionConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1175{
     1176    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestExceptionConstructorGetter>(*state, thisValue, "TestException");
     1177}
     1178
     1179static inline bool setJSTestGlobalObjectTestExceptionConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1180{
     1181    UNUSED_PARAM(throwScope);
     1182    // Shadowing a built-in constructor.
     1183    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestException"), strlen("TestException")), value);
     1184}
     1185
     1186bool setJSTestGlobalObjectTestExceptionConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1187{
     1188    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestExceptionConstructorSetter>(*state, thisValue, encodedValue, "TestException");
     1189}
     1190
     1191static inline JSValue jsTestGlobalObjectTestGenerateIsReachableConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1192{
     1193    UNUSED_PARAM(throwScope);
     1194    UNUSED_PARAM(state);
     1195    return JSTestGenerateIsReachable::getConstructor(state.vm(), thisObject.globalObject());
     1196}
     1197
     1198EncodedJSValue jsTestGlobalObjectTestGenerateIsReachableConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1199{
     1200    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestGenerateIsReachableConstructorGetter>(*state, thisValue, "TestGenerateIsReachable");
     1201}
     1202
     1203static inline bool setJSTestGlobalObjectTestGenerateIsReachableConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1204{
     1205    UNUSED_PARAM(throwScope);
     1206    // Shadowing a built-in constructor.
     1207    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestGenerateIsReachable"), strlen("TestGenerateIsReachable")), value);
     1208}
     1209
     1210bool setJSTestGlobalObjectTestGenerateIsReachableConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1211{
     1212    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestGenerateIsReachableConstructorSetter>(*state, thisValue, encodedValue, "TestGenerateIsReachable");
     1213}
     1214
     1215static inline JSValue jsTestGlobalObjectTestGlobalObjectConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1216{
     1217    UNUSED_PARAM(throwScope);
     1218    UNUSED_PARAM(state);
     1219    return JSTestGlobalObject::getConstructor(state.vm(), thisObject.globalObject());
     1220}
     1221
     1222EncodedJSValue jsTestGlobalObjectTestGlobalObjectConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1223{
     1224    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestGlobalObjectConstructorGetter>(*state, thisValue, "TestGlobalObject");
     1225}
     1226
     1227static inline bool setJSTestGlobalObjectTestGlobalObjectConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1228{
     1229    UNUSED_PARAM(throwScope);
     1230    // Shadowing a built-in constructor.
     1231    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestGlobalObject"), strlen("TestGlobalObject")), value);
     1232}
     1233
     1234bool setJSTestGlobalObjectTestGlobalObjectConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1235{
     1236    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestGlobalObjectConstructorSetter>(*state, thisValue, encodedValue, "TestGlobalObject");
     1237}
     1238
     1239static inline JSValue jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1240{
     1241    UNUSED_PARAM(throwScope);
     1242    UNUSED_PARAM(state);
     1243    return JSTestIndexedSetterNoIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1244}
     1245
     1246EncodedJSValue jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1247{
     1248    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIndexedSetterNoIdentifierConstructorGetter>(*state, thisValue, "TestIndexedSetterNoIdentifier");
     1249}
     1250
     1251static inline bool setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1252{
     1253    UNUSED_PARAM(throwScope);
     1254    // Shadowing a built-in constructor.
     1255    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestIndexedSetterNoIdentifier"), strlen("TestIndexedSetterNoIdentifier")), value);
     1256}
     1257
     1258bool setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1259{
     1260    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIndexedSetterNoIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestIndexedSetterNoIdentifier");
     1261}
     1262
     1263static inline JSValue jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1264{
     1265    UNUSED_PARAM(throwScope);
     1266    UNUSED_PARAM(state);
     1267    return JSTestIndexedSetterThrowingException::getConstructor(state.vm(), thisObject.globalObject());
     1268}
     1269
     1270EncodedJSValue jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1271{
     1272    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorGetter>(*state, thisValue, "TestIndexedSetterThrowingException");
     1273}
     1274
     1275static inline bool setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1276{
     1277    UNUSED_PARAM(throwScope);
     1278    // Shadowing a built-in constructor.
     1279    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestIndexedSetterThrowingException"), strlen("TestIndexedSetterThrowingException")), value);
     1280}
     1281
     1282bool setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1283{
     1284    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIndexedSetterThrowingExceptionConstructorSetter>(*state, thisValue, encodedValue, "TestIndexedSetterThrowingException");
     1285}
     1286
     1287static inline JSValue jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1288{
     1289    UNUSED_PARAM(throwScope);
     1290    UNUSED_PARAM(state);
     1291    return JSTestIndexedSetterWithIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1292}
     1293
     1294EncodedJSValue jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1295{
     1296    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIndexedSetterWithIdentifierConstructorGetter>(*state, thisValue, "TestIndexedSetterWithIdentifier");
     1297}
     1298
     1299static inline bool setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1300{
     1301    UNUSED_PARAM(throwScope);
     1302    // Shadowing a built-in constructor.
     1303    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestIndexedSetterWithIdentifier"), strlen("TestIndexedSetterWithIdentifier")), value);
     1304}
     1305
     1306bool setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1307{
     1308    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIndexedSetterWithIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestIndexedSetterWithIdentifier");
     1309}
     1310
     1311#if ENABLE(Condition1) || ENABLE(Condition2)
     1312static inline JSValue jsTestGlobalObjectTestInterfaceConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1313{
     1314    UNUSED_PARAM(throwScope);
     1315    UNUSED_PARAM(state);
     1316    return JSTestInterface::getConstructor(state.vm(), thisObject.globalObject());
     1317}
     1318
     1319EncodedJSValue jsTestGlobalObjectTestInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1320{
     1321    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestInterfaceConstructorGetter>(*state, thisValue, "TestInterface");
     1322}
     1323
     1324#endif
     1325
     1326#if ENABLE(Condition1) || ENABLE(Condition2)
     1327static inline bool setJSTestGlobalObjectTestInterfaceConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1328{
     1329    UNUSED_PARAM(throwScope);
     1330    // Shadowing a built-in constructor.
     1331    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestInterface"), strlen("TestInterface")), value);
     1332}
     1333
     1334bool setJSTestGlobalObjectTestInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1335{
     1336    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestInterfaceConstructorSetter>(*state, thisValue, encodedValue, "TestInterface");
     1337}
     1338
     1339#endif
     1340
     1341static inline JSValue jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1342{
     1343    UNUSED_PARAM(throwScope);
     1344    UNUSED_PARAM(state);
     1345    return JSTestInterfaceLeadingUnderscore::getConstructor(state.vm(), thisObject.globalObject());
     1346}
     1347
     1348EncodedJSValue jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1349{
     1350    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorGetter>(*state, thisValue, "TestInterfaceLeadingUnderscore");
     1351}
     1352
     1353static inline bool setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1354{
     1355    UNUSED_PARAM(throwScope);
     1356    // Shadowing a built-in constructor.
     1357    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestInterfaceLeadingUnderscore"), strlen("TestInterfaceLeadingUnderscore")), value);
     1358}
     1359
     1360bool setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1361{
     1362    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestInterfaceLeadingUnderscoreConstructorSetter>(*state, thisValue, encodedValue, "TestInterfaceLeadingUnderscore");
     1363}
     1364
     1365static inline JSValue jsTestGlobalObjectTestIterableConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1366{
     1367    UNUSED_PARAM(throwScope);
     1368    UNUSED_PARAM(state);
     1369    return JSTestIterable::getConstructor(state.vm(), thisObject.globalObject());
     1370}
     1371
     1372EncodedJSValue jsTestGlobalObjectTestIterableConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1373{
     1374    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestIterableConstructorGetter>(*state, thisValue, "TestIterable");
     1375}
     1376
     1377static inline bool setJSTestGlobalObjectTestIterableConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1378{
     1379    UNUSED_PARAM(throwScope);
     1380    // Shadowing a built-in constructor.
     1381    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestIterable"), strlen("TestIterable")), value);
     1382}
     1383
     1384bool setJSTestGlobalObjectTestIterableConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1385{
     1386    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestIterableConstructorSetter>(*state, thisValue, encodedValue, "TestIterable");
     1387}
     1388
     1389static inline JSValue jsTestGlobalObjectTestJSBuiltinConstructorConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1390{
     1391    UNUSED_PARAM(throwScope);
     1392    UNUSED_PARAM(state);
     1393    return JSTestJSBuiltinConstructor::getConstructor(state.vm(), thisObject.globalObject());
     1394}
     1395
     1396EncodedJSValue jsTestGlobalObjectTestJSBuiltinConstructorConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1397{
     1398    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestJSBuiltinConstructorConstructorGetter>(*state, thisValue, "TestJSBuiltinConstructor");
     1399}
     1400
     1401static inline bool setJSTestGlobalObjectTestJSBuiltinConstructorConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1402{
     1403    UNUSED_PARAM(throwScope);
     1404    // Shadowing a built-in constructor.
     1405    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestJSBuiltinConstructor"), strlen("TestJSBuiltinConstructor")), value);
     1406}
     1407
     1408bool setJSTestGlobalObjectTestJSBuiltinConstructorConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1409{
     1410    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestJSBuiltinConstructorConstructorSetter>(*state, thisValue, encodedValue, "TestJSBuiltinConstructor");
     1411}
     1412
     1413static inline JSValue jsTestGlobalObjectTestMapLikeConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1414{
     1415    UNUSED_PARAM(throwScope);
     1416    UNUSED_PARAM(state);
     1417    return JSTestMapLike::getConstructor(state.vm(), thisObject.globalObject());
     1418}
     1419
     1420EncodedJSValue jsTestGlobalObjectTestMapLikeConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1421{
     1422    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestMapLikeConstructorGetter>(*state, thisValue, "TestMapLike");
     1423}
     1424
     1425static inline bool setJSTestGlobalObjectTestMapLikeConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1426{
     1427    UNUSED_PARAM(throwScope);
     1428    // Shadowing a built-in constructor.
     1429    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestMapLike"), strlen("TestMapLike")), value);
     1430}
     1431
     1432bool setJSTestGlobalObjectTestMapLikeConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1433{
     1434    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestMapLikeConstructorSetter>(*state, thisValue, encodedValue, "TestMapLike");
     1435}
     1436
     1437static inline JSValue jsTestGlobalObjectTestMediaQueryListListenerConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1438{
     1439    UNUSED_PARAM(throwScope);
     1440    UNUSED_PARAM(state);
     1441    return JSTestMediaQueryListListener::getConstructor(state.vm(), thisObject.globalObject());
     1442}
     1443
     1444EncodedJSValue jsTestGlobalObjectTestMediaQueryListListenerConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1445{
     1446    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestMediaQueryListListenerConstructorGetter>(*state, thisValue, "TestMediaQueryListListener");
     1447}
     1448
     1449static inline bool setJSTestGlobalObjectTestMediaQueryListListenerConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1450{
     1451    UNUSED_PARAM(throwScope);
     1452    // Shadowing a built-in constructor.
     1453    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestMediaQueryListListener"), strlen("TestMediaQueryListListener")), value);
     1454}
     1455
     1456bool setJSTestGlobalObjectTestMediaQueryListListenerConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1457{
     1458    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestMediaQueryListListenerConstructorSetter>(*state, thisValue, encodedValue, "TestMediaQueryListListener");
     1459}
     1460
     1461static inline JSValue jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1462{
     1463    UNUSED_PARAM(throwScope);
     1464    UNUSED_PARAM(state);
     1465    return JSTestNamedAndIndexedSetterNoIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1466}
     1467
     1468EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1469{
     1470    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorGetter>(*state, thisValue, "TestNamedAndIndexedSetterNoIdentifier");
     1471}
     1472
     1473static inline bool setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1474{
     1475    UNUSED_PARAM(throwScope);
     1476    // Shadowing a built-in constructor.
     1477    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedAndIndexedSetterNoIdentifier"), strlen("TestNamedAndIndexedSetterNoIdentifier")), value);
     1478}
     1479
     1480bool setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1481{
     1482    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedAndIndexedSetterNoIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedAndIndexedSetterNoIdentifier");
     1483}
     1484
     1485static inline JSValue jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1486{
     1487    UNUSED_PARAM(throwScope);
     1488    UNUSED_PARAM(state);
     1489    return JSTestNamedAndIndexedSetterThrowingException::getConstructor(state.vm(), thisObject.globalObject());
     1490}
     1491
     1492EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1493{
     1494    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorGetter>(*state, thisValue, "TestNamedAndIndexedSetterThrowingException");
     1495}
     1496
     1497static inline bool setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1498{
     1499    UNUSED_PARAM(throwScope);
     1500    // Shadowing a built-in constructor.
     1501    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedAndIndexedSetterThrowingException"), strlen("TestNamedAndIndexedSetterThrowingException")), value);
     1502}
     1503
     1504bool setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1505{
     1506    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedAndIndexedSetterThrowingExceptionConstructorSetter>(*state, thisValue, encodedValue, "TestNamedAndIndexedSetterThrowingException");
     1507}
     1508
     1509static inline JSValue jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1510{
     1511    UNUSED_PARAM(throwScope);
     1512    UNUSED_PARAM(state);
     1513    return JSTestNamedAndIndexedSetterWithIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1514}
     1515
     1516EncodedJSValue jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1517{
     1518    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorGetter>(*state, thisValue, "TestNamedAndIndexedSetterWithIdentifier");
     1519}
     1520
     1521static inline bool setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1522{
     1523    UNUSED_PARAM(throwScope);
     1524    // Shadowing a built-in constructor.
     1525    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedAndIndexedSetterWithIdentifier"), strlen("TestNamedAndIndexedSetterWithIdentifier")), value);
     1526}
     1527
     1528bool setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1529{
     1530    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedAndIndexedSetterWithIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedAndIndexedSetterWithIdentifier");
     1531}
     1532
     1533static inline JSValue jsTestGlobalObjectTestNamedConstructorConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1534{
     1535    UNUSED_PARAM(throwScope);
     1536    UNUSED_PARAM(state);
     1537    return JSTestNamedConstructor::getConstructor(state.vm(), thisObject.globalObject());
     1538}
     1539
     1540EncodedJSValue jsTestGlobalObjectTestNamedConstructorConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1541{
     1542    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedConstructorConstructorGetter>(*state, thisValue, "TestNamedConstructor");
     1543}
     1544
     1545static inline bool setJSTestGlobalObjectTestNamedConstructorConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1546{
     1547    UNUSED_PARAM(throwScope);
     1548    // Shadowing a built-in constructor.
     1549    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedConstructor"), strlen("TestNamedConstructor")), value);
     1550}
     1551
     1552bool setJSTestGlobalObjectTestNamedConstructorConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1553{
     1554    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedConstructorConstructorSetter>(*state, thisValue, encodedValue, "TestNamedConstructor");
     1555}
     1556
     1557static inline JSValue jsTestGlobalObjectAudioConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1558{
     1559    UNUSED_PARAM(throwScope);
     1560    UNUSED_PARAM(state);
     1561    return JSTestNamedConstructorNamed::getConstructor(state.vm(), thisObject.globalObject());
     1562}
     1563
     1564EncodedJSValue jsTestGlobalObjectAudioConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1565{
     1566    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectAudioConstructorGetter>(*state, thisValue, "Audio");
     1567}
     1568
     1569static inline bool setJSTestGlobalObjectAudioConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1570{
     1571    UNUSED_PARAM(throwScope);
     1572    // Shadowing a built-in constructor.
     1573    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("Audio"), strlen("Audio")), value);
     1574}
     1575
     1576bool setJSTestGlobalObjectAudioConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1577{
     1578    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectAudioConstructorSetter>(*state, thisValue, encodedValue, "Audio");
     1579}
     1580
     1581static inline JSValue jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1582{
     1583    UNUSED_PARAM(throwScope);
     1584    UNUSED_PARAM(state);
     1585    return JSTestNamedDeleterNoIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1586}
     1587
     1588EncodedJSValue jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1589{
     1590    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterNoIdentifierConstructorGetter>(*state, thisValue, "TestNamedDeleterNoIdentifier");
     1591}
     1592
     1593static inline bool setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1594{
     1595    UNUSED_PARAM(throwScope);
     1596    // Shadowing a built-in constructor.
     1597    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedDeleterNoIdentifier"), strlen("TestNamedDeleterNoIdentifier")), value);
     1598}
     1599
     1600bool setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1601{
     1602    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterNoIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedDeleterNoIdentifier");
     1603}
     1604
     1605static inline JSValue jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1606{
     1607    UNUSED_PARAM(throwScope);
     1608    UNUSED_PARAM(state);
     1609    return JSTestNamedDeleterThrowingException::getConstructor(state.vm(), thisObject.globalObject());
     1610}
     1611
     1612EncodedJSValue jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1613{
     1614    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorGetter>(*state, thisValue, "TestNamedDeleterThrowingException");
     1615}
     1616
     1617static inline bool setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1618{
     1619    UNUSED_PARAM(throwScope);
     1620    // Shadowing a built-in constructor.
     1621    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedDeleterThrowingException"), strlen("TestNamedDeleterThrowingException")), value);
     1622}
     1623
     1624bool setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1625{
     1626    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterThrowingExceptionConstructorSetter>(*state, thisValue, encodedValue, "TestNamedDeleterThrowingException");
     1627}
     1628
     1629static inline JSValue jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1630{
     1631    UNUSED_PARAM(throwScope);
     1632    UNUSED_PARAM(state);
     1633    return JSTestNamedDeleterWithIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1634}
     1635
     1636EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1637{
     1638    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterWithIdentifierConstructorGetter>(*state, thisValue, "TestNamedDeleterWithIdentifier");
     1639}
     1640
     1641static inline bool setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1642{
     1643    UNUSED_PARAM(throwScope);
     1644    // Shadowing a built-in constructor.
     1645    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedDeleterWithIdentifier"), strlen("TestNamedDeleterWithIdentifier")), value);
     1646}
     1647
     1648bool setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1649{
     1650    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterWithIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedDeleterWithIdentifier");
     1651}
     1652
     1653static inline JSValue jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1654{
     1655    UNUSED_PARAM(throwScope);
     1656    UNUSED_PARAM(state);
     1657    return JSTestNamedDeleterWithIndexedGetter::getConstructor(state.vm(), thisObject.globalObject());
     1658}
     1659
     1660EncodedJSValue jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1661{
     1662    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorGetter>(*state, thisValue, "TestNamedDeleterWithIndexedGetter");
     1663}
     1664
     1665static inline bool setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1666{
     1667    UNUSED_PARAM(throwScope);
     1668    // Shadowing a built-in constructor.
     1669    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedDeleterWithIndexedGetter"), strlen("TestNamedDeleterWithIndexedGetter")), value);
     1670}
     1671
     1672bool setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1673{
     1674    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedDeleterWithIndexedGetterConstructorSetter>(*state, thisValue, encodedValue, "TestNamedDeleterWithIndexedGetter");
     1675}
     1676
     1677static inline JSValue jsTestGlobalObjectTestNamedGetterCallWithConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1678{
     1679    UNUSED_PARAM(throwScope);
     1680    UNUSED_PARAM(state);
     1681    return JSTestNamedGetterCallWith::getConstructor(state.vm(), thisObject.globalObject());
     1682}
     1683
     1684EncodedJSValue jsTestGlobalObjectTestNamedGetterCallWithConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1685{
     1686    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedGetterCallWithConstructorGetter>(*state, thisValue, "TestNamedGetterCallWith");
     1687}
     1688
     1689static inline bool setJSTestGlobalObjectTestNamedGetterCallWithConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1690{
     1691    UNUSED_PARAM(throwScope);
     1692    // Shadowing a built-in constructor.
     1693    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedGetterCallWith"), strlen("TestNamedGetterCallWith")), value);
     1694}
     1695
     1696bool setJSTestGlobalObjectTestNamedGetterCallWithConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1697{
     1698    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedGetterCallWithConstructorSetter>(*state, thisValue, encodedValue, "TestNamedGetterCallWith");
     1699}
     1700
     1701static inline JSValue jsTestGlobalObjectTestNamedGetterNoIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1702{
     1703    UNUSED_PARAM(throwScope);
     1704    UNUSED_PARAM(state);
     1705    return JSTestNamedGetterNoIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1706}
     1707
     1708EncodedJSValue jsTestGlobalObjectTestNamedGetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1709{
     1710    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedGetterNoIdentifierConstructorGetter>(*state, thisValue, "TestNamedGetterNoIdentifier");
     1711}
     1712
     1713static inline bool setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1714{
     1715    UNUSED_PARAM(throwScope);
     1716    // Shadowing a built-in constructor.
     1717    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedGetterNoIdentifier"), strlen("TestNamedGetterNoIdentifier")), value);
     1718}
     1719
     1720bool setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1721{
     1722    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedGetterNoIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedGetterNoIdentifier");
     1723}
     1724
     1725static inline JSValue jsTestGlobalObjectTestNamedGetterWithIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1726{
     1727    UNUSED_PARAM(throwScope);
     1728    UNUSED_PARAM(state);
     1729    return JSTestNamedGetterWithIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1730}
     1731
     1732EncodedJSValue jsTestGlobalObjectTestNamedGetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1733{
     1734    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedGetterWithIdentifierConstructorGetter>(*state, thisValue, "TestNamedGetterWithIdentifier");
     1735}
     1736
     1737static inline bool setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1738{
     1739    UNUSED_PARAM(throwScope);
     1740    // Shadowing a built-in constructor.
     1741    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedGetterWithIdentifier"), strlen("TestNamedGetterWithIdentifier")), value);
     1742}
     1743
     1744bool setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1745{
     1746    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedGetterWithIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedGetterWithIdentifier");
     1747}
     1748
     1749static inline JSValue jsTestGlobalObjectTestNamedSetterNoIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1750{
     1751    UNUSED_PARAM(throwScope);
     1752    UNUSED_PARAM(state);
     1753    return JSTestNamedSetterNoIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1754}
     1755
     1756EncodedJSValue jsTestGlobalObjectTestNamedSetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1757{
     1758    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterNoIdentifierConstructorGetter>(*state, thisValue, "TestNamedSetterNoIdentifier");
     1759}
     1760
     1761static inline bool setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1762{
     1763    UNUSED_PARAM(throwScope);
     1764    // Shadowing a built-in constructor.
     1765    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterNoIdentifier"), strlen("TestNamedSetterNoIdentifier")), value);
     1766}
     1767
     1768bool setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1769{
     1770    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterNoIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterNoIdentifier");
     1771}
     1772
     1773static inline JSValue jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1774{
     1775    UNUSED_PARAM(throwScope);
     1776    UNUSED_PARAM(state);
     1777    return JSTestNamedSetterThrowingException::getConstructor(state.vm(), thisObject.globalObject());
     1778}
     1779
     1780EncodedJSValue jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1781{
     1782    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterThrowingExceptionConstructorGetter>(*state, thisValue, "TestNamedSetterThrowingException");
     1783}
     1784
     1785static inline bool setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1786{
     1787    UNUSED_PARAM(throwScope);
     1788    // Shadowing a built-in constructor.
     1789    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterThrowingException"), strlen("TestNamedSetterThrowingException")), value);
     1790}
     1791
     1792bool setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1793{
     1794    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterThrowingExceptionConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterThrowingException");
     1795}
     1796
     1797static inline JSValue jsTestGlobalObjectTestNamedSetterWithIdentifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1798{
     1799    UNUSED_PARAM(throwScope);
     1800    UNUSED_PARAM(state);
     1801    return JSTestNamedSetterWithIdentifier::getConstructor(state.vm(), thisObject.globalObject());
     1802}
     1803
     1804EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1805{
     1806    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithIdentifierConstructorGetter>(*state, thisValue, "TestNamedSetterWithIdentifier");
     1807}
     1808
     1809static inline bool setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1810{
     1811    UNUSED_PARAM(throwScope);
     1812    // Shadowing a built-in constructor.
     1813    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterWithIdentifier"), strlen("TestNamedSetterWithIdentifier")), value);
     1814}
     1815
     1816bool setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1817{
     1818    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithIdentifierConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterWithIdentifier");
     1819}
     1820
     1821static inline JSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1822{
     1823    UNUSED_PARAM(throwScope);
     1824    UNUSED_PARAM(state);
     1825    return JSTestNamedSetterWithIndexedGetter::getConstructor(state.vm(), thisObject.globalObject());
     1826}
     1827
     1828EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1829{
     1830    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorGetter>(*state, thisValue, "TestNamedSetterWithIndexedGetter");
     1831}
     1832
     1833static inline bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1834{
     1835    UNUSED_PARAM(throwScope);
     1836    // Shadowing a built-in constructor.
     1837    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterWithIndexedGetter"), strlen("TestNamedSetterWithIndexedGetter")), value);
     1838}
     1839
     1840bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1841{
     1842    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithIndexedGetterConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterWithIndexedGetter");
     1843}
     1844
     1845static inline JSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1846{
     1847    UNUSED_PARAM(throwScope);
     1848    UNUSED_PARAM(state);
     1849    return JSTestNamedSetterWithIndexedGetterAndSetter::getConstructor(state.vm(), thisObject.globalObject());
     1850}
     1851
     1852EncodedJSValue jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1853{
     1854    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorGetter>(*state, thisValue, "TestNamedSetterWithIndexedGetterAndSetter");
     1855}
     1856
     1857static inline bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1858{
     1859    UNUSED_PARAM(throwScope);
     1860    // Shadowing a built-in constructor.
     1861    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterWithIndexedGetterAndSetter"), strlen("TestNamedSetterWithIndexedGetterAndSetter")), value);
     1862}
     1863
     1864bool setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1865{
     1866    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithIndexedGetterAndSetterConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterWithIndexedGetterAndSetter");
     1867}
     1868
     1869static inline JSValue jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1870{
     1871    UNUSED_PARAM(throwScope);
     1872    UNUSED_PARAM(state);
     1873    return JSTestNamedSetterWithOverrideBuiltins::getConstructor(state.vm(), thisObject.globalObject());
     1874}
     1875
     1876EncodedJSValue jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1877{
     1878    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorGetter>(*state, thisValue, "TestNamedSetterWithOverrideBuiltins");
     1879}
     1880
     1881static inline bool setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1882{
     1883    UNUSED_PARAM(throwScope);
     1884    // Shadowing a built-in constructor.
     1885    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterWithOverrideBuiltins"), strlen("TestNamedSetterWithOverrideBuiltins")), value);
     1886}
     1887
     1888bool setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1889{
     1890    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithOverrideBuiltinsConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterWithOverrideBuiltins");
     1891}
     1892
     1893static inline JSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1894{
     1895    UNUSED_PARAM(throwScope);
     1896    UNUSED_PARAM(state);
     1897    return JSTestNamedSetterWithUnforgableProperties::getConstructor(state.vm(), thisObject.globalObject());
     1898}
     1899
     1900EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1901{
     1902    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorGetter>(*state, thisValue, "TestNamedSetterWithUnforgableProperties");
     1903}
     1904
     1905static inline bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1906{
     1907    UNUSED_PARAM(throwScope);
     1908    // Shadowing a built-in constructor.
     1909    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterWithUnforgableProperties"), strlen("TestNamedSetterWithUnforgableProperties")), value);
     1910}
     1911
     1912bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1913{
     1914    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterWithUnforgableProperties");
     1915}
     1916
     1917static inline JSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1918{
     1919    UNUSED_PARAM(throwScope);
     1920    UNUSED_PARAM(state);
     1921    return JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::getConstructor(state.vm(), thisObject.globalObject());
     1922}
     1923
     1924EncodedJSValue jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1925{
     1926    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorGetter>(*state, thisValue, "TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins");
     1927}
     1928
     1929static inline bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1930{
     1931    UNUSED_PARAM(throwScope);
     1932    // Shadowing a built-in constructor.
     1933    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins"), strlen("TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins")), value);
     1934}
     1935
     1936bool setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1937{
     1938    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsConstructorSetter>(*state, thisValue, encodedValue, "TestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins");
     1939}
     1940
     1941static inline JSValue jsTestGlobalObjectTestOverloadedConstructorsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1942{
     1943    UNUSED_PARAM(throwScope);
     1944    UNUSED_PARAM(state);
     1945    return JSTestOverloadedConstructors::getConstructor(state.vm(), thisObject.globalObject());
     1946}
     1947
     1948EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1949{
     1950    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestOverloadedConstructorsConstructorGetter>(*state, thisValue, "TestOverloadedConstructors");
     1951}
     1952
     1953static inline bool setJSTestGlobalObjectTestOverloadedConstructorsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1954{
     1955    UNUSED_PARAM(throwScope);
     1956    // Shadowing a built-in constructor.
     1957    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestOverloadedConstructors"), strlen("TestOverloadedConstructors")), value);
     1958}
     1959
     1960bool setJSTestGlobalObjectTestOverloadedConstructorsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1961{
     1962    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestOverloadedConstructorsConstructorSetter>(*state, thisValue, encodedValue, "TestOverloadedConstructors");
     1963}
     1964
     1965static inline JSValue jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1966{
     1967    UNUSED_PARAM(throwScope);
     1968    UNUSED_PARAM(state);
     1969    return JSTestOverloadedConstructorsWithSequence::getConstructor(state.vm(), thisObject.globalObject());
     1970}
     1971
     1972EncodedJSValue jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1973{
     1974    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorGetter>(*state, thisValue, "TestOverloadedConstructorsWithSequence");
     1975}
     1976
     1977static inline bool setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     1978{
     1979    UNUSED_PARAM(throwScope);
     1980    // Shadowing a built-in constructor.
     1981    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestOverloadedConstructorsWithSequence"), strlen("TestOverloadedConstructorsWithSequence")), value);
     1982}
     1983
     1984bool setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     1985{
     1986    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestOverloadedConstructorsWithSequenceConstructorSetter>(*state, thisValue, encodedValue, "TestOverloadedConstructorsWithSequence");
     1987}
     1988
     1989static inline JSValue jsTestGlobalObjectTestOverrideBuiltinsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     1990{
     1991    UNUSED_PARAM(throwScope);
     1992    UNUSED_PARAM(state);
     1993    return JSTestOverrideBuiltins::getConstructor(state.vm(), thisObject.globalObject());
     1994}
     1995
     1996EncodedJSValue jsTestGlobalObjectTestOverrideBuiltinsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     1997{
     1998    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestOverrideBuiltinsConstructorGetter>(*state, thisValue, "TestOverrideBuiltins");
     1999}
     2000
     2001static inline bool setJSTestGlobalObjectTestOverrideBuiltinsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2002{
     2003    UNUSED_PARAM(throwScope);
     2004    // Shadowing a built-in constructor.
     2005    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestOverrideBuiltins"), strlen("TestOverrideBuiltins")), value);
     2006}
     2007
     2008bool setJSTestGlobalObjectTestOverrideBuiltinsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2009{
     2010    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestOverrideBuiltinsConstructorSetter>(*state, thisValue, encodedValue, "TestOverrideBuiltins");
     2011}
     2012
     2013static inline JSValue jsTestGlobalObjectTestPluginInterfaceConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2014{
     2015    UNUSED_PARAM(throwScope);
     2016    UNUSED_PARAM(state);
     2017    return JSTestPluginInterface::getConstructor(state.vm(), thisObject.globalObject());
     2018}
     2019
     2020EncodedJSValue jsTestGlobalObjectTestPluginInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2021{
     2022    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestPluginInterfaceConstructorGetter>(*state, thisValue, "TestPluginInterface");
     2023}
     2024
     2025static inline bool setJSTestGlobalObjectTestPluginInterfaceConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2026{
     2027    UNUSED_PARAM(throwScope);
     2028    // Shadowing a built-in constructor.
     2029    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestPluginInterface"), strlen("TestPluginInterface")), value);
     2030}
     2031
     2032bool setJSTestGlobalObjectTestPluginInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2033{
     2034    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestPluginInterfaceConstructorSetter>(*state, thisValue, encodedValue, "TestPluginInterface");
     2035}
     2036
     2037static inline JSValue jsTestGlobalObjectTestReadOnlyMapLikeConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2038{
     2039    UNUSED_PARAM(throwScope);
     2040    UNUSED_PARAM(state);
     2041    return JSTestReadOnlyMapLike::getConstructor(state.vm(), thisObject.globalObject());
     2042}
     2043
     2044EncodedJSValue jsTestGlobalObjectTestReadOnlyMapLikeConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2045{
     2046    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestReadOnlyMapLikeConstructorGetter>(*state, thisValue, "TestReadOnlyMapLike");
     2047}
     2048
     2049static inline bool setJSTestGlobalObjectTestReadOnlyMapLikeConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2050{
     2051    UNUSED_PARAM(throwScope);
     2052    // Shadowing a built-in constructor.
     2053    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestReadOnlyMapLike"), strlen("TestReadOnlyMapLike")), value);
     2054}
     2055
     2056bool setJSTestGlobalObjectTestReadOnlyMapLikeConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2057{
     2058    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestReadOnlyMapLikeConstructorSetter>(*state, thisValue, encodedValue, "TestReadOnlyMapLike");
     2059}
     2060
     2061static inline JSValue jsTestGlobalObjectTestReportExtraMemoryCostConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2062{
     2063    UNUSED_PARAM(throwScope);
     2064    UNUSED_PARAM(state);
     2065    return JSTestReportExtraMemoryCost::getConstructor(state.vm(), thisObject.globalObject());
     2066}
     2067
     2068EncodedJSValue jsTestGlobalObjectTestReportExtraMemoryCostConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2069{
     2070    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestReportExtraMemoryCostConstructorGetter>(*state, thisValue, "TestReportExtraMemoryCost");
     2071}
     2072
     2073static inline bool setJSTestGlobalObjectTestReportExtraMemoryCostConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2074{
     2075    UNUSED_PARAM(throwScope);
     2076    // Shadowing a built-in constructor.
     2077    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestReportExtraMemoryCost"), strlen("TestReportExtraMemoryCost")), value);
     2078}
     2079
     2080bool setJSTestGlobalObjectTestReportExtraMemoryCostConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2081{
     2082    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestReportExtraMemoryCostConstructorSetter>(*state, thisValue, encodedValue, "TestReportExtraMemoryCost");
     2083}
     2084
     2085static inline JSValue jsTestGlobalObjectTestSerializationConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2086{
     2087    UNUSED_PARAM(throwScope);
     2088    UNUSED_PARAM(state);
     2089    return JSTestSerialization::getConstructor(state.vm(), thisObject.globalObject());
     2090}
     2091
     2092EncodedJSValue jsTestGlobalObjectTestSerializationConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2093{
     2094    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationConstructorGetter>(*state, thisValue, "TestSerialization");
     2095}
     2096
     2097static inline bool setJSTestGlobalObjectTestSerializationConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2098{
     2099    UNUSED_PARAM(throwScope);
     2100    // Shadowing a built-in constructor.
     2101    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestSerialization"), strlen("TestSerialization")), value);
     2102}
     2103
     2104bool setJSTestGlobalObjectTestSerializationConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2105{
     2106    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationConstructorSetter>(*state, thisValue, encodedValue, "TestSerialization");
     2107}
     2108
     2109static inline JSValue jsTestGlobalObjectTestSerializationIndirectInheritanceConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2110{
     2111    UNUSED_PARAM(throwScope);
     2112    UNUSED_PARAM(state);
     2113    return JSTestSerializationIndirectInheritance::getConstructor(state.vm(), thisObject.globalObject());
     2114}
     2115
     2116EncodedJSValue jsTestGlobalObjectTestSerializationIndirectInheritanceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2117{
     2118    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationIndirectInheritanceConstructorGetter>(*state, thisValue, "TestSerializationIndirectInheritance");
     2119}
     2120
     2121static inline bool setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2122{
     2123    UNUSED_PARAM(throwScope);
     2124    // Shadowing a built-in constructor.
     2125    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestSerializationIndirectInheritance"), strlen("TestSerializationIndirectInheritance")), value);
     2126}
     2127
     2128bool setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2129{
     2130    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationIndirectInheritanceConstructorSetter>(*state, thisValue, encodedValue, "TestSerializationIndirectInheritance");
     2131}
     2132
     2133static inline JSValue jsTestGlobalObjectTestSerializationInheritConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2134{
     2135    UNUSED_PARAM(throwScope);
     2136    UNUSED_PARAM(state);
     2137    return JSTestSerializationInherit::getConstructor(state.vm(), thisObject.globalObject());
     2138}
     2139
     2140EncodedJSValue jsTestGlobalObjectTestSerializationInheritConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2141{
     2142    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationInheritConstructorGetter>(*state, thisValue, "TestSerializationInherit");
     2143}
     2144
     2145static inline bool setJSTestGlobalObjectTestSerializationInheritConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2146{
     2147    UNUSED_PARAM(throwScope);
     2148    // Shadowing a built-in constructor.
     2149    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestSerializationInherit"), strlen("TestSerializationInherit")), value);
     2150}
     2151
     2152bool setJSTestGlobalObjectTestSerializationInheritConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2153{
     2154    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationInheritConstructorSetter>(*state, thisValue, encodedValue, "TestSerializationInherit");
     2155}
     2156
     2157static inline JSValue jsTestGlobalObjectTestSerializationInheritFinalConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2158{
     2159    UNUSED_PARAM(throwScope);
     2160    UNUSED_PARAM(state);
     2161    return JSTestSerializationInheritFinal::getConstructor(state.vm(), thisObject.globalObject());
     2162}
     2163
     2164EncodedJSValue jsTestGlobalObjectTestSerializationInheritFinalConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2165{
     2166    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializationInheritFinalConstructorGetter>(*state, thisValue, "TestSerializationInheritFinal");
     2167}
     2168
     2169static inline bool setJSTestGlobalObjectTestSerializationInheritFinalConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2170{
     2171    UNUSED_PARAM(throwScope);
     2172    // Shadowing a built-in constructor.
     2173    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestSerializationInheritFinal"), strlen("TestSerializationInheritFinal")), value);
     2174}
     2175
     2176bool setJSTestGlobalObjectTestSerializationInheritFinalConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2177{
     2178    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializationInheritFinalConstructorSetter>(*state, thisValue, encodedValue, "TestSerializationInheritFinal");
     2179}
     2180
     2181#if ENABLE(Condition1) || ENABLE(Condition2)
     2182static inline JSValue jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2183{
     2184    UNUSED_PARAM(throwScope);
     2185    UNUSED_PARAM(state);
     2186    return JSTestSerializedScriptValueInterface::getConstructor(state.vm(), thisObject.globalObject());
     2187}
     2188
     2189EncodedJSValue jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2190{
     2191    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestSerializedScriptValueInterfaceConstructorGetter>(*state, thisValue, "TestSerializedScriptValueInterface");
     2192}
     2193
     2194#endif
     2195
     2196#if ENABLE(Condition1) || ENABLE(Condition2)
     2197static inline bool setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2198{
     2199    UNUSED_PARAM(throwScope);
     2200    // Shadowing a built-in constructor.
     2201    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestSerializedScriptValueInterface"), strlen("TestSerializedScriptValueInterface")), value);
     2202}
     2203
     2204bool setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2205{
     2206    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestSerializedScriptValueInterfaceConstructorSetter>(*state, thisValue, encodedValue, "TestSerializedScriptValueInterface");
     2207}
     2208
     2209#endif
     2210
     2211static inline JSValue jsTestGlobalObjectTestStringifierConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2212{
     2213    UNUSED_PARAM(throwScope);
     2214    UNUSED_PARAM(state);
     2215    return JSTestStringifier::getConstructor(state.vm(), thisObject.globalObject());
     2216}
     2217
     2218EncodedJSValue jsTestGlobalObjectTestStringifierConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2219{
     2220    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierConstructorGetter>(*state, thisValue, "TestStringifier");
     2221}
     2222
     2223static inline bool setJSTestGlobalObjectTestStringifierConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2224{
     2225    UNUSED_PARAM(throwScope);
     2226    // Shadowing a built-in constructor.
     2227    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifier"), strlen("TestStringifier")), value);
     2228}
     2229
     2230bool setJSTestGlobalObjectTestStringifierConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2231{
     2232    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierConstructorSetter>(*state, thisValue, encodedValue, "TestStringifier");
     2233}
     2234
     2235static inline JSValue jsTestGlobalObjectTestStringifierAnonymousOperationConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2236{
     2237    UNUSED_PARAM(throwScope);
     2238    UNUSED_PARAM(state);
     2239    return JSTestStringifierAnonymousOperation::getConstructor(state.vm(), thisObject.globalObject());
     2240}
     2241
     2242EncodedJSValue jsTestGlobalObjectTestStringifierAnonymousOperationConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2243{
     2244    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierAnonymousOperationConstructorGetter>(*state, thisValue, "TestStringifierAnonymousOperation");
     2245}
     2246
     2247static inline bool setJSTestGlobalObjectTestStringifierAnonymousOperationConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2248{
     2249    UNUSED_PARAM(throwScope);
     2250    // Shadowing a built-in constructor.
     2251    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifierAnonymousOperation"), strlen("TestStringifierAnonymousOperation")), value);
     2252}
     2253
     2254bool setJSTestGlobalObjectTestStringifierAnonymousOperationConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2255{
     2256    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierAnonymousOperationConstructorSetter>(*state, thisValue, encodedValue, "TestStringifierAnonymousOperation");
     2257}
     2258
     2259static inline JSValue jsTestGlobalObjectTestStringifierNamedOperationConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2260{
     2261    UNUSED_PARAM(throwScope);
     2262    UNUSED_PARAM(state);
     2263    return JSTestStringifierNamedOperation::getConstructor(state.vm(), thisObject.globalObject());
     2264}
     2265
     2266EncodedJSValue jsTestGlobalObjectTestStringifierNamedOperationConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2267{
     2268    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierNamedOperationConstructorGetter>(*state, thisValue, "TestStringifierNamedOperation");
     2269}
     2270
     2271static inline bool setJSTestGlobalObjectTestStringifierNamedOperationConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2272{
     2273    UNUSED_PARAM(throwScope);
     2274    // Shadowing a built-in constructor.
     2275    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifierNamedOperation"), strlen("TestStringifierNamedOperation")), value);
     2276}
     2277
     2278bool setJSTestGlobalObjectTestStringifierNamedOperationConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2279{
     2280    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierNamedOperationConstructorSetter>(*state, thisValue, encodedValue, "TestStringifierNamedOperation");
     2281}
     2282
     2283static inline JSValue jsTestGlobalObjectTestStringifierOperationImplementedAsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2284{
     2285    UNUSED_PARAM(throwScope);
     2286    UNUSED_PARAM(state);
     2287    return JSTestStringifierOperationImplementedAs::getConstructor(state.vm(), thisObject.globalObject());
     2288}
     2289
     2290EncodedJSValue jsTestGlobalObjectTestStringifierOperationImplementedAsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2291{
     2292    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierOperationImplementedAsConstructorGetter>(*state, thisValue, "TestStringifierOperationImplementedAs");
     2293}
     2294
     2295static inline bool setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2296{
     2297    UNUSED_PARAM(throwScope);
     2298    // Shadowing a built-in constructor.
     2299    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifierOperationImplementedAs"), strlen("TestStringifierOperationImplementedAs")), value);
     2300}
     2301
     2302bool setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2303{
     2304    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierOperationImplementedAsConstructorSetter>(*state, thisValue, encodedValue, "TestStringifierOperationImplementedAs");
     2305}
     2306
     2307static inline JSValue jsTestGlobalObjectTestStringifierOperationNamedToStringConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2308{
     2309    UNUSED_PARAM(throwScope);
     2310    UNUSED_PARAM(state);
     2311    return JSTestStringifierOperationNamedToString::getConstructor(state.vm(), thisObject.globalObject());
     2312}
     2313
     2314EncodedJSValue jsTestGlobalObjectTestStringifierOperationNamedToStringConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2315{
     2316    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierOperationNamedToStringConstructorGetter>(*state, thisValue, "TestStringifierOperationNamedToString");
     2317}
     2318
     2319static inline bool setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2320{
     2321    UNUSED_PARAM(throwScope);
     2322    // Shadowing a built-in constructor.
     2323    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifierOperationNamedToString"), strlen("TestStringifierOperationNamedToString")), value);
     2324}
     2325
     2326bool setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2327{
     2328    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierOperationNamedToStringConstructorSetter>(*state, thisValue, encodedValue, "TestStringifierOperationNamedToString");
     2329}
     2330
     2331static inline JSValue jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2332{
     2333    UNUSED_PARAM(throwScope);
     2334    UNUSED_PARAM(state);
     2335    return JSTestStringifierReadOnlyAttribute::getConstructor(state.vm(), thisObject.globalObject());
     2336}
     2337
     2338EncodedJSValue jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2339{
     2340    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierReadOnlyAttributeConstructorGetter>(*state, thisValue, "TestStringifierReadOnlyAttribute");
     2341}
     2342
     2343static inline bool setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2344{
     2345    UNUSED_PARAM(throwScope);
     2346    // Shadowing a built-in constructor.
     2347    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifierReadOnlyAttribute"), strlen("TestStringifierReadOnlyAttribute")), value);
     2348}
     2349
     2350bool setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2351{
     2352    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierReadOnlyAttributeConstructorSetter>(*state, thisValue, encodedValue, "TestStringifierReadOnlyAttribute");
     2353}
     2354
     2355static inline JSValue jsTestGlobalObjectTestStringifierReadWriteAttributeConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2356{
     2357    UNUSED_PARAM(throwScope);
     2358    UNUSED_PARAM(state);
     2359    return JSTestStringifierReadWriteAttribute::getConstructor(state.vm(), thisObject.globalObject());
     2360}
     2361
     2362EncodedJSValue jsTestGlobalObjectTestStringifierReadWriteAttributeConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2363{
     2364    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestStringifierReadWriteAttributeConstructorGetter>(*state, thisValue, "TestStringifierReadWriteAttribute");
     2365}
     2366
     2367static inline bool setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2368{
     2369    UNUSED_PARAM(throwScope);
     2370    // Shadowing a built-in constructor.
     2371    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestStringifierReadWriteAttribute"), strlen("TestStringifierReadWriteAttribute")), value);
     2372}
     2373
     2374bool setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2375{
     2376    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestStringifierReadWriteAttributeConstructorSetter>(*state, thisValue, encodedValue, "TestStringifierReadWriteAttribute");
     2377}
     2378
     2379static inline JSValue jsTestGlobalObjectTestTypedefsConstructorGetter(ExecState& state, JSTestGlobalObject& thisObject, ThrowScope& throwScope)
     2380{
     2381    UNUSED_PARAM(throwScope);
     2382    UNUSED_PARAM(state);
     2383    return JSTestTypedefs::getConstructor(state.vm(), thisObject.globalObject());
     2384}
     2385
     2386EncodedJSValue jsTestGlobalObjectTestTypedefsConstructor(ExecState* state, EncodedJSValue thisValue, PropertyName)
     2387{
     2388    return IDLAttribute<JSTestGlobalObject>::get<jsTestGlobalObjectTestTypedefsConstructorGetter>(*state, thisValue, "TestTypedefs");
     2389}
     2390
     2391static inline bool setJSTestGlobalObjectTestTypedefsConstructorSetter(ExecState& state, JSTestGlobalObject& thisObject, JSValue value, ThrowScope& throwScope)
     2392{
     2393    UNUSED_PARAM(throwScope);
     2394    // Shadowing a built-in constructor.
     2395    return thisObject.putDirect(state.vm(), Identifier::fromString(&state.vm(), reinterpret_cast<const LChar*>("TestTypedefs"), strlen("TestTypedefs")), value);
     2396}
     2397
     2398bool setJSTestGlobalObjectTestTypedefsConstructor(ExecState* state, EncodedJSValue thisValue, EncodedJSValue encodedValue)
     2399{
     2400    return IDLAttribute<JSTestGlobalObject>::set<setJSTestGlobalObjectTestTypedefsConstructorSetter>(*state, thisValue, encodedValue, "TestTypedefs");
     2401}
     2402
    4032403static inline JSC::EncodedJSValue jsTestGlobalObjectInstanceFunctionRegularOperationBody(JSC::ExecState* state, typename IDLOperation<JSTestGlobalObject>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
    4042404{

  • trunk/Tools/ChangeLog

    r245034 r245036  
     12019-05-07  Andy Estes  <aestes@apple.com>
     2
     3        run-bindings-tests should test global scope constructor generation
     4        https://bugs.webkit.org/show_bug.cgi?id=197669
     5
     6        Reviewed by Alex Christensen.
     7
     8        * Scripts/webkitpy/bindings/main.py:
     9        Updated to specify --testGlobalContextName and --testGlobalScopeConstructorsFile when
     10        invoking preprocess-idls.pl.
     11
    1122019-05-07  Youenn Fablet  <youenn@apple.com>
    213

  • trunk/Tools/Scripts/webkitpy/bindings/main.py

    r238081 r245036  
    7171        return exit_code
    7272
    73     def generate_supplemental_dependency(self, input_directory, supplemental_dependency_file, window_constructors_file, workerglobalscope_constructors_file, dedicatedworkerglobalscope_constructors_file, serviceworkerglobalscope_constructors_file, workletglobalscope_constructors_file, paintworkletglobalscope_constructors_file):
     73    def generate_supplemental_dependency(self, input_directory, supplemental_dependency_file, window_constructors_file, workerglobalscope_constructors_file, dedicatedworkerglobalscope_constructors_file, serviceworkerglobalscope_constructors_file, workletglobalscope_constructors_file, paintworkletglobalscope_constructors_file, testglobalscope_constructors_file):
    7474        idl_files_list = tempfile.mkstemp()
    7575        for input_file in os.listdir(input_directory):
    … …  
    8484               'WebCore/bindings/scripts/preprocess-idls.pl',
    8585               '--idlFilesList', idl_files_list[1],
     86               '--testGlobalContextName', 'TestGlobalObject',
    8687               '--defines', '',
    8788               '--supplementalDependencyFile', supplemental_dependency_file,
    … …  
    9192               '--serviceWorkerGlobalScopeConstructorsFile', serviceworkerglobalscope_constructors_file,
    9293               '--workletGlobalScopeConstructorsFile', workletglobalscope_constructors_file,
    93                '--paintWorkletGlobalScopeConstructorsFile', paintworkletglobalscope_constructors_file]
     94               '--paintWorkletGlobalScopeConstructorsFile', paintworkletglobalscope_constructors_file,
     95               '--testGlobalScopeConstructorsFile', testglobalscope_constructors_file]
    9496
    9597        exit_code = 0
    … …  
    191193        workletglobalscope_constructors_file = tempfile.mkstemp()
    192194        paintworkletglobalscope_constructors_file = tempfile.mkstemp()
    193         if self.generate_supplemental_dependency(input_directory, supplemental_dependency_file[1], window_constructors_file[1], workerglobalscope_constructors_file[1], dedicatedworkerglobalscope_constructors_file[1], serviceworkerglobalscope_constructors_file[1], workletglobalscope_constructors_file[1], paintworkletglobalscope_constructors_file[1]):
     195        testglobalscope_constructors_file = tempfile.mkstemp()
     196        if self.generate_supplemental_dependency(input_directory, supplemental_dependency_file[1], window_constructors_file[1], workerglobalscope_constructors_file[1], dedicatedworkerglobalscope_constructors_file[1], serviceworkerglobalscope_constructors_file[1], workletglobalscope_constructors_file[1], paintworkletglobalscope_constructors_file[1], testglobalscope_constructors_file[1]):
    194197            print('Failed to generate a supplemental dependency file.')
    195198            self.close_and_remove(supplemental_dependency_file)
    … …  
    200203            self.close_and_remove(workletglobalscope_constructors_file)
    201204            self.close_and_remove(paintworkletglobalscope_constructors_file)
     205            self.close_and_remove(testglobalscope_constructors_file)
    202206            return -1
    203207
    … …  
    215219        self.close_and_remove(workletglobalscope_constructors_file)
    216220        self.close_and_remove(paintworkletglobalscope_constructors_file)
     221        self.close_and_remove(testglobalscope_constructors_file)
    217222
    218223        if self.json_file_name:
Note: See TracChangeset for help on using the changeset viewer.