ChangeLog

2020-03-04  Yusuke Suzuki  <ysuzuki@apple.com>

        Put all generated JSCells in WebCore into IsoSubspace

        https://bugs.webkit.org/show_bug.cgi?id=205107

        Reviewed by NOBODY (OOPS!).

        This patch automatically generates IsoSubspace per WebCore DOM object type.

        In preprocess-idls.pl, we collect all the DOM object types and generate DOMIsoSubspaces class,

        which contains all the necessary IsoSubspaces. And it is held by WebCoreJSClientData.

        CodeGeneratorJS.pm starts putting `subspaceFor` and `subspaceForImpl` for each JS DOM wrapper classes.

        And we dynamically create IsoSubspace and set it to WebCoreJSClientData's DOMIsoSubspaces. At the same

        time, we register IsoSubspace to m_outputConstraintSpaces if the class has output constraits callback.

        * CMakeLists.txt:

        * DerivedSources-output.xcfilelist:

        * DerivedSources.make:

        * WebCoreMacros.cmake:

        * bindings/js/JSDOMWrapper.cpp:

        (WebCore::outputConstraintSubspaceFor): Deleted.

        * bindings/js/JSDOMWrapper.h:

        * bindings/js/WebCoreJSClientData.cpp:

        (WebCore::JSVMClientData::JSVMClientData):

        * bindings/js/WebCoreJSClientData.h:

        (WebCore::JSVMClientData::forEachOutputConstraintSpace):

        (WebCore::JSVMClientData::subspaces):

        (WebCore::JSVMClientData::outputConstraintSpace): Deleted.

        (WebCore::JSVMClientData::subspaceForJSDOMWindow): Deleted.

        (WebCore::JSVMClientData::subspaceForJSDedicatedWorkerGlobalScope): Deleted.

        (WebCore::JSVMClientData::subspaceForJSRemoteDOMWindow): Deleted.

        (WebCore::JSVMClientData::subspaceForJSWorkerGlobalScope): Deleted.

        (WebCore::JSVMClientData::subspaceForJSServiceWorkerGlobalScope): Deleted.

        (WebCore::JSVMClientData::subspaceForJSPaintWorkletGlobalScope): Deleted.

        (WebCore::JSVMClientData::subspaceForJSWorkletGlobalScope): Deleted.

        * bindings/scripts/CodeGeneratorJS.pm:

        (GenerateHeader):

        (GenerateImplementation):

        * bindings/scripts/generate-bindings-all.pl:

        * bindings/scripts/preprocess-idls.pl:

        * bindings/scripts/test/JS/JSInterfaceName.cpp:

        (WebCore::JSInterfaceName::subspaceForImpl):

        * bindings/scripts/test/JS/JSInterfaceName.h:

        (WebCore::JSInterfaceName::subspaceFor):

        * bindings/scripts/test/JS/JSMapLike.cpp:

        (WebCore::JSMapLike::subspaceForImpl):

        * bindings/scripts/test/JS/JSMapLike.h:

        (WebCore::JSMapLike::subspaceFor):

        * bindings/scripts/test/JS/JSReadOnlyMapLike.cpp:

        (WebCore::JSReadOnlyMapLike::subspaceForImpl):

        * bindings/scripts/test/JS/JSReadOnlyMapLike.h:

        (WebCore::JSReadOnlyMapLike::subspaceFor):

        * bindings/scripts/test/JS/JSReadOnlySetLike.cpp:

        (WebCore::JSReadOnlySetLike::subspaceForImpl):

        * bindings/scripts/test/JS/JSReadOnlySetLike.h:

        (WebCore::JSReadOnlySetLike::subspaceFor):

        * bindings/scripts/test/JS/JSSetLike.cpp:

        (WebCore::JSSetLike::subspaceForImpl):

        * bindings/scripts/test/JS/JSSetLike.h:

        (WebCore::JSSetLike::subspaceFor):

        * bindings/scripts/test/JS/JSTestActiveDOMObject.cpp:

        (WebCore::JSTestActiveDOMObject::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestActiveDOMObject.h:

        (WebCore::JSTestActiveDOMObject::subspaceFor):

        * bindings/scripts/test/JS/JSTestCEReactions.cpp:

        (WebCore::JSTestCEReactions::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestCEReactions.h:

        (WebCore::JSTestCEReactions::subspaceFor):

        * bindings/scripts/test/JS/JSTestCEReactionsStringifier.cpp:

        (WebCore::JSTestCEReactionsStringifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestCEReactionsStringifier.h:

        (WebCore::JSTestCEReactionsStringifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestCallTracer.cpp:

        (WebCore::JSTestCallTracer::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestCallTracer.h:

        (WebCore::JSTestCallTracer::subspaceFor):

        * bindings/scripts/test/JS/JSTestClassWithJSBuiltinConstructor.cpp:

        (WebCore::JSTestClassWithJSBuiltinConstructor::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestClassWithJSBuiltinConstructor.h:

        (WebCore::JSTestClassWithJSBuiltinConstructor::subspaceFor):

        * bindings/scripts/test/JS/JSTestDOMJIT.cpp:

        (WebCore::JSTestDOMJIT::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestDOMJIT.h:

        (WebCore::JSTestDOMJIT::subspaceFor):

        * bindings/scripts/test/JS/JSTestEnabledBySetting.cpp:

        (WebCore::JSTestEnabledBySetting::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestEnabledBySetting.h:

        (WebCore::JSTestEnabledBySetting::subspaceFor):

        * bindings/scripts/test/JS/JSTestEnabledForContext.cpp:

        (WebCore::JSTestEnabledForContext::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestEnabledForContext.h:

        (WebCore::JSTestEnabledForContext::subspaceFor):

        * bindings/scripts/test/JS/JSTestEventConstructor.cpp:

        (WebCore::JSTestEventConstructor::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestEventConstructor.h:

        (WebCore::JSTestEventConstructor::subspaceFor):

        * bindings/scripts/test/JS/JSTestEventTarget.cpp:

        (WebCore::JSTestEventTarget::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestEventTarget.h:

        (WebCore::JSTestEventTarget::subspaceFor):

        * bindings/scripts/test/JS/JSTestException.cpp:

        (WebCore::JSTestException::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestException.h:

        (WebCore::JSTestException::subspaceFor):

        * bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp:

        (WebCore::JSTestGenerateIsReachable::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestGenerateIsReachable.h:

        (WebCore::JSTestGenerateIsReachable::subspaceFor):

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

        (WebCore::JSTestGlobalObject::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestGlobalObject.h:

        (WebCore::JSTestGlobalObject::subspaceFor):

        * bindings/scripts/test/JS/JSTestIndexedSetterNoIdentifier.cpp:

        (WebCore::JSTestIndexedSetterNoIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestIndexedSetterNoIdentifier.h:

        (WebCore::JSTestIndexedSetterNoIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestIndexedSetterThrowingException.cpp:

        (WebCore::JSTestIndexedSetterThrowingException::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestIndexedSetterThrowingException.h:

        (WebCore::JSTestIndexedSetterThrowingException::subspaceFor):

        * bindings/scripts/test/JS/JSTestIndexedSetterWithIdentifier.cpp:

        (WebCore::JSTestIndexedSetterWithIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestIndexedSetterWithIdentifier.h:

        (WebCore::JSTestIndexedSetterWithIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestInterface.cpp:

        (WebCore::JSTestInterface::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestInterface.h:

        * bindings/scripts/test/JS/JSTestInterfaceLeadingUnderscore.cpp:

        (WebCore::JSTestInterfaceLeadingUnderscore::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestInterfaceLeadingUnderscore.h:

        (WebCore::JSTestInterfaceLeadingUnderscore::subspaceFor):

        * bindings/scripts/test/JS/JSTestIterable.cpp:

        (WebCore::JSTestIterable::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestIterable.h:

        (WebCore::JSTestIterable::subspaceFor):

        * bindings/scripts/test/JS/JSTestJSBuiltinConstructor.cpp:

        (WebCore::JSTestJSBuiltinConstructor::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestJSBuiltinConstructor.h:

        (WebCore::JSTestJSBuiltinConstructor::subspaceFor):

        * bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp:

        (WebCore::JSTestMediaQueryListListener::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestMediaQueryListListener.h:

        (WebCore::JSTestMediaQueryListListener::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedAndIndexedSetterNoIdentifier.cpp:

        (WebCore::JSTestNamedAndIndexedSetterNoIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedAndIndexedSetterNoIdentifier.h:

        (WebCore::JSTestNamedAndIndexedSetterNoIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedAndIndexedSetterThrowingException.cpp:

        (WebCore::JSTestNamedAndIndexedSetterThrowingException::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedAndIndexedSetterThrowingException.h:

        (WebCore::JSTestNamedAndIndexedSetterThrowingException::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedAndIndexedSetterWithIdentifier.cpp:

        (WebCore::JSTestNamedAndIndexedSetterWithIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedAndIndexedSetterWithIdentifier.h:

        (WebCore::JSTestNamedAndIndexedSetterWithIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedConstructor.cpp:

        (WebCore::JSTestNamedConstructor::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedConstructor.h:

        (WebCore::JSTestNamedConstructor::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedDeleterNoIdentifier.cpp:

        (WebCore::JSTestNamedDeleterNoIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedDeleterNoIdentifier.h:

        (WebCore::JSTestNamedDeleterNoIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedDeleterThrowingException.cpp:

        (WebCore::JSTestNamedDeleterThrowingException::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedDeleterThrowingException.h:

        (WebCore::JSTestNamedDeleterThrowingException::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedDeleterWithIdentifier.cpp:

        (WebCore::JSTestNamedDeleterWithIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedDeleterWithIdentifier.h:

        (WebCore::JSTestNamedDeleterWithIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedDeleterWithIndexedGetter.cpp:

        (WebCore::JSTestNamedDeleterWithIndexedGetter::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedDeleterWithIndexedGetter.h:

        (WebCore::JSTestNamedDeleterWithIndexedGetter::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedGetterCallWith.cpp:

        (WebCore::JSTestNamedGetterCallWith::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedGetterCallWith.h:

        (WebCore::JSTestNamedGetterCallWith::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedGetterNoIdentifier.cpp:

        (WebCore::JSTestNamedGetterNoIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedGetterNoIdentifier.h:

        (WebCore::JSTestNamedGetterNoIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedGetterWithIdentifier.cpp:

        (WebCore::JSTestNamedGetterWithIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedGetterWithIdentifier.h:

        (WebCore::JSTestNamedGetterWithIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterNoIdentifier.cpp:

        (WebCore::JSTestNamedSetterNoIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterNoIdentifier.h:

        (WebCore::JSTestNamedSetterNoIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterThrowingException.cpp:

        (WebCore::JSTestNamedSetterThrowingException::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterThrowingException.h:

        (WebCore::JSTestNamedSetterThrowingException::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterWithIdentifier.cpp:

        (WebCore::JSTestNamedSetterWithIdentifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterWithIdentifier.h:

        (WebCore::JSTestNamedSetterWithIdentifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetter.cpp:

        (WebCore::JSTestNamedSetterWithIndexedGetter::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetter.h:

        (WebCore::JSTestNamedSetterWithIndexedGetter::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetterAndSetter.cpp:

        (WebCore::JSTestNamedSetterWithIndexedGetterAndSetter::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetterAndSetter.h:

        (WebCore::JSTestNamedSetterWithIndexedGetterAndSetter::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterWithOverrideBuiltins.cpp:

        (WebCore::JSTestNamedSetterWithOverrideBuiltins::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterWithOverrideBuiltins.h:

        (WebCore::JSTestNamedSetterWithOverrideBuiltins::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterWithUnforgableProperties.cpp:

        (WebCore::JSTestNamedSetterWithUnforgableProperties::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterWithUnforgableProperties.h:

        (WebCore::JSTestNamedSetterWithUnforgableProperties::subspaceFor):

        * bindings/scripts/test/JS/JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.cpp:

        (WebCore::JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.h:

        (WebCore::JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::subspaceFor):

        * bindings/scripts/test/JS/JSTestNode.cpp:

        (WebCore::JSTestNode::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestNode.h:

        * bindings/scripts/test/JS/JSTestObj.cpp:

        (WebCore::JSTestObj::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestObj.h:

        (WebCore::JSTestObj::subspaceFor):

        * bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp:

        (WebCore::JSTestOverloadedConstructors::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestOverloadedConstructors.h:

        (WebCore::JSTestOverloadedConstructors::subspaceFor):

        * bindings/scripts/test/JS/JSTestOverloadedConstructorsWithSequence.cpp:

        (WebCore::JSTestOverloadedConstructorsWithSequence::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestOverloadedConstructorsWithSequence.h:

        (WebCore::JSTestOverloadedConstructorsWithSequence::subspaceFor):

        * bindings/scripts/test/JS/JSTestOverrideBuiltins.cpp:

        (WebCore::JSTestOverrideBuiltins::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestOverrideBuiltins.h:

        (WebCore::JSTestOverrideBuiltins::subspaceFor):

        * bindings/scripts/test/JS/JSTestPluginInterface.cpp:

        (WebCore::JSTestPluginInterface::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestPluginInterface.h:

        (WebCore::JSTestPluginInterface::subspaceFor):

        * bindings/scripts/test/JS/JSTestPromiseRejectionEvent.cpp:

        (WebCore::JSTestPromiseRejectionEvent::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestPromiseRejectionEvent.h:

        (WebCore::JSTestPromiseRejectionEvent::subspaceFor):

        * bindings/scripts/test/JS/JSTestSerialization.cpp:

        (WebCore::JSTestSerialization::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestSerialization.h:

        (WebCore::JSTestSerialization::subspaceFor):

        * bindings/scripts/test/JS/JSTestSerializationIndirectInheritance.cpp:

        (WebCore::JSTestSerializationIndirectInheritance::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestSerializationIndirectInheritance.h:

        (WebCore::JSTestSerializationIndirectInheritance::subspaceFor):

        * bindings/scripts/test/JS/JSTestSerializationInherit.cpp:

        (WebCore::JSTestSerializationInherit::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestSerializationInherit.h:

        (WebCore::JSTestSerializationInherit::subspaceFor):

        * bindings/scripts/test/JS/JSTestSerializationInheritFinal.cpp:

        (WebCore::JSTestSerializationInheritFinal::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestSerializationInheritFinal.h:

        (WebCore::JSTestSerializationInheritFinal::subspaceFor):

        * bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp:

        (WebCore::JSTestSerializedScriptValueInterface::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.h:

        (WebCore::JSTestSerializedScriptValueInterface::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifier.cpp:

        (WebCore::JSTestStringifier::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifier.h:

        (WebCore::JSTestStringifier::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifierAnonymousOperation.cpp:

        (WebCore::JSTestStringifierAnonymousOperation::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifierAnonymousOperation.h:

        (WebCore::JSTestStringifierAnonymousOperation::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifierNamedOperation.cpp:

        (WebCore::JSTestStringifierNamedOperation::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifierNamedOperation.h:

        (WebCore::JSTestStringifierNamedOperation::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifierOperationImplementedAs.cpp:

        (WebCore::JSTestStringifierOperationImplementedAs::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifierOperationImplementedAs.h:

        (WebCore::JSTestStringifierOperationImplementedAs::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifierOperationNamedToString.cpp:

        (WebCore::JSTestStringifierOperationNamedToString::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifierOperationNamedToString.h:

        (WebCore::JSTestStringifierOperationNamedToString::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifierReadOnlyAttribute.cpp:

        (WebCore::JSTestStringifierReadOnlyAttribute::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifierReadOnlyAttribute.h:

        (WebCore::JSTestStringifierReadOnlyAttribute::subspaceFor):

        * bindings/scripts/test/JS/JSTestStringifierReadWriteAttribute.cpp:

        (WebCore::JSTestStringifierReadWriteAttribute::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestStringifierReadWriteAttribute.h:

        (WebCore::JSTestStringifierReadWriteAttribute::subspaceFor):

        * bindings/scripts/test/JS/JSTestTypedefs.cpp:

        (WebCore::JSTestTypedefs::subspaceForImpl):

        * bindings/scripts/test/JS/JSTestTypedefs.h:

        (WebCore::JSTestTypedefs::subspaceFor):

2020-03-04  Antoine Quint  <graouts@apple.com>

        Add an SPI to allow UserStyleSheet injection to target a specific WKWebView

Source/WebCore/CMakeLists.txt

@@set(MAKE_NAMES_DEPENDENCIES

    ${WEBCORE_DIR}/bindings/scripts/StaticString.pm

)

set(SUPPLEMENTAL_DEPENDENCY_FILE ${WebCore_DERIVED_SOURCES_DIR}/supplemental_dependency.tmp)

1639set(ISO_SUBSPACES_HEADER_FILE ${WebCore_DERIVED_SOURCES_DIR}/DOMIsoSubspaces.h)

set(WINDOW_CONSTRUCTORS_FILE ${WebCore_DERIVED_SOURCES_DIR}/DOMWindowConstructors.idl)

set(WORKERGLOBALSCOPE_CONSTRUCTORS_FILE ${WebCore_DERIVED_SOURCES_DIR}/WorkerGlobalScopeConstructors.idl)

set(DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE ${WebCore_DERIVED_SOURCES_DIR}/DedicatedWorkerGlobalScopeConstructors.idl)

@@list(APPEND WebCoreTestSupport_IDL_FILES ${WebCore_DERIVED_SOURCES_DIR}/Internal

GENERATE_BINDINGS(WebCoreBindings

    OUTPUT_SOURCE WebCore_SOURCES

    INPUT_FILES ${WebCore_IDL_FILES}

1808 PP_INPUT_FILES ${WebCore_IDL_FILES} ${WebCoreTestSupport_IDL_FILES}

    BASE_DIR ${WEBCORE_DIR}

    IDL_INCLUDES ${WebCore_IDL_INCLUDES} ${WebCore_DERIVED_SOURCES_DIR}

    FEATURES ${FEATURE_DEFINES_JAVASCRIPT}

@@GENERATE_BINDINGS(WebCoreBindings

    GENERATOR JS

    SUPPLEMENTAL_DEPFILE ${SUPPLEMENTAL_DEPENDENCY_FILE}

    PP_EXTRA_OUTPUT

1814 ${WINDOW_CONSTRUCTORS_FILE} ${WORKERGLOBALSCOPE_CONSTRUCTORS_FILE} ${DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE}

1816 ${ISO_SUBSPACES_HEADER_FILE} ${WINDOW_CONSTRUCTORS_FILE} ${WORKERGLOBALSCOPE_CONSTRUCTORS_FILE} ${DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE}

18151817 PP_EXTRA_ARGS

1818 --isoSubspacesHeaderFile ${ISO_SUBSPACES_HEADER_FILE}

        --windowConstructorsFile ${WINDOW_CONSTRUCTORS_FILE}

        --workerGlobalScopeConstructorsFile ${WORKERGLOBALSCOPE_CONSTRUCTORS_FILE}

        --dedicatedWorkerGlobalScopeConstructorsFile ${DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE}

Source/WebCore/DerivedSources-output.xcfilelist

@@$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/CSSValueKeywords.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/ColorData.cpp

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/CommandLineAPIModuleSource.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/CountQueuingStrategyBuiltins.h

12$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/DOMIsoSubspaces.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/DOMJITAbstractHeapRepository.h

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/DOMWindowConstructors.idl

$(BUILT_PRODUCTS_DIR)/DerivedSources/WebCore/DedicatedWorkerGlobalScopeConstructors.idl

Source/WebCore/DerivedSources.make

@@JS_BINDINGS_SCRIPTS = $(COMMON_BINDINGS_SCRIPTS) bindings/scripts/CodeGeneratorJ

SUPPLEMENTAL_DEPENDENCY_FILE = SupplementalDependencies.txt

SUPPLEMENTAL_MAKEFILE_DEPS = SupplementalDependencies.dep

1721ISO_SUBSPACES_HEADER_FILE = DOMIsoSubspaces.h

WINDOW_CONSTRUCTORS_FILE = DOMWindowConstructors.idl

WORKERGLOBALSCOPE_CONSTRUCTORS_FILE = WorkerGlobalScopeConstructors.idl

DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE = DedicatedWorkerGlobalScopeConstructors.idl

@@endef

IDL_INTERMEDIATE_FILES = \

    $(SUPPLEMENTAL_MAKEFILE_DEPS) \

    $(SUPPLEMENTAL_DEPENDENCY_FILE) \

1742 $(ISO_SUBSPACES_HEADER_FILE) \

    $(WINDOW_CONSTRUCTORS_FILE) \

    $(WORKERGLOBALSCOPE_CONSTRUCTORS_FILE) \

    $(DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE) \

@@IDL_INTERMEDIATE_PATTERNS = $(subst .,%,$(IDL_INTERMEDIATE_FILES))

$(IDL_INTERMEDIATE_PATTERNS) : $(PREPROCESS_IDLS_SCRIPTS) $(JS_BINDING_IDLS) $(PLATFORM_FEATURE_DEFINES) DerivedSources.make

	$(foreach f,$(JS_BINDING_IDLS),@echo $(f)>>$(IDL_FILES_TMP)$(NL))

1752 $(PERL) $(WebCore)/bindings/scripts/preprocess-idls.pl --defines "$(FEATURE_AND_PLATFORM_DEFINES) $(ADDITIONAL_IDL_DEFINES) LANGUAGE_JAVASCRIPT" --idlFilesList $(IDL_FILES_TMP) --supplementalDependencyFile $(SUPPLEMENTAL_DEPENDENCY_FILE) --windowConstructorsFile $(WINDOW_CONSTRUCTORS_FILE) --workerGlobalScopeConstructorsFile $(WORKERGLOBALSCOPE_CONSTRUCTORS_FILE) --dedicatedWorkerGlobalScopeConstructorsFile $(DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE) --serviceWorkerGlobalScopeConstructorsFile $(SERVICEWORKERGLOBALSCOPE_CONSTRUCTORS_FILE) --workletGlobalScopeConstructorsFile $(WORKLETGLOBALSCOPE_CONSTRUCTORS_FILE) --paintWorkletGlobalScopeConstructorsFile $(PAINTWORKLETGLOBALSCOPE_CONSTRUCTORS_FILE) --supplementalMakefileDeps $(SUPPLEMENTAL_MAKEFILE_DEPS)

1754 $(PERL) $(WebCore)/bindings/scripts/preprocess-idls.pl --defines "$(FEATURE_AND_PLATFORM_DEFINES) $(ADDITIONAL_IDL_DEFINES) LANGUAGE_JAVASCRIPT" --idlFilesList $(IDL_FILES_TMP) --supplementalDependencyFile $(SUPPLEMENTAL_DEPENDENCY_FILE) --isoSubspacesHeaderFile $(ISO_SUBSPACES_HEADER_FILE) --windowConstructorsFile $(WINDOW_CONSTRUCTORS_FILE) --workerGlobalScopeConstructorsFile $(WORKERGLOBALSCOPE_CONSTRUCTORS_FILE) --dedicatedWorkerGlobalScopeConstructorsFile $(DEDICATEDWORKERGLOBALSCOPE_CONSTRUCTORS_FILE) --serviceWorkerGlobalScopeConstructorsFile $(SERVICEWORKERGLOBALSCOPE_CONSTRUCTORS_FILE) --workletGlobalScopeConstructorsFile $(WORKLETGLOBALSCOPE_CONSTRUCTORS_FILE) --paintWorkletGlobalScopeConstructorsFile $(PAINTWORKLETGLOBALSCOPE_CONSTRUCTORS_FILE) --supplementalMakefileDeps $(SUPPLEMENTAL_MAKEFILE_DEPS)

	$(DELETE) $(IDL_FILES_TMP)

JS%.cpp JS%.h : %.idl $(JS_BINDINGS_SCRIPTS) $(IDL_ATTRIBUTES_FILE) $(IDL_INTERMEDIATE_FILES) $(PLATFORM_FEATURE_DEFINES)

Source/WebCore/WebCoreMacros.cmake

@@option(SHOW_BINDINGS_GENERATION_PROGRESS "Show progress of generating bindings"

#   target is a new target name to be added

#   OUTPUT_SOURCE is a list name which will contain generated sources.(eg. WebCore_SOURCES)

#   INPUT_FILES are IDL files to generate.

51# PP_INPUT_FILES are IDL files to preprocess.

#   BASE_DIR is base directory where script is called.

#   IDL_INCLUDES is value of --include argument. (eg. ${WEBCORE_DIR}/bindings/js)

#   FEATURES is a value of --defines argument.

@@option(SHOW_BINDINGS_GENERATION_PROGRESS "Show progress of generating bindings"

function(GENERATE_BINDINGS target)

    set(options)

    set(oneValueArgs OUTPUT_SOURCE BASE_DIR FEATURES DESTINATION GENERATOR SUPPLEMENTAL_DEPFILE)

62 set(multiValueArgs INPUT_FILES IDL_INCLUDES PP_EXTRA_OUTPUT PP_EXTRA_ARGS)

63 set(multiValueArgs INPUT_FILES PP_INPUT_FILES IDL_INCLUDES PP_EXTRA_OUTPUT PP_EXTRA_ARGS)

    cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

    set(binding_generator ${WEBCORE_DIR}/bindings/scripts/generate-bindings-all.pl)

    set(idl_attributes_file ${WEBCORE_DIR}/bindings/scripts/IDLAttributes.json)

    set(idl_files_list ${CMAKE_CURRENT_BINARY_DIR}/idl_files_${target}.tmp)

68 set(pp_idl_files_list ${CMAKE_CURRENT_BINARY_DIR}/pp_idl_files_${target}.tmp)

    set(_supplemental_dependency)

    set(content)

@@function(GENERATE_BINDINGS target)

    endforeach ()

    file(WRITE ${idl_files_list} ${content})

    set(pp_content)

    foreach (f ${arg_PP_INPUT_FILES})

        if (NOT IS_ABSOLUTE ${f})

            set(f ${CMAKE_CURRENT_SOURCE_DIR}/${f})

        endif ()

        set(pp_content "${pp_content}${f}\n")

    endforeach ()

    file(WRITE ${pp_idl_files_list} ${pp_content})

    set(args

        --defines ${arg_FEATURES}

        --generator ${arg_GENERATOR}

        --outputDir ${arg_DESTINATION}

        --idlFilesList ${idl_files_list}

94 --ppIDLFilesList ${pp_idl_files_list}

        --preprocessor "${CODE_GENERATOR_PREPROCESSOR}"

        --idlAttributesFile ${idl_attributes_file}

    )

Source/WebCore/bindings/js/JSDOMWrapper.cpp

@@JSDOMObject::JSDOMObject(JSC::Structure* structure, JSC::JSGlobalObject& globalO

    ASSERT(scriptExecutionContext() || globalObject.classInfo(globalObject.vm()) == JSRemoteDOMWindow::info());

}

JSC::CompleteSubspace* outputConstraintSubspaceFor(JSC::VM& vm)

{

    return &static_cast<JSVMClientData*>(vm.clientData)->outputConstraintSpace();

}

JSC::JSValue cloneAcrossWorlds(JSC::JSGlobalObject& lexicalGlobalObject, const JSDOMObject& owner, JSC::JSValue value)

{

    if (isWorldCompatible(lexicalGlobalObject, value))

Source/WebCore/bindings/js/JSDOMWrapper.h

@@class JSDOMObject : public JSC::JSDestructibleObject {

    WEBCORE_EXPORT JSDOMObject(JSC::Structure*, JSC::JSGlobalObject&);

};

69 WEBCORE_EXPORT JSC::CompleteSubspace* outputConstraintSubspaceFor(JSC::VM&);

70

template<typename ImplementationClass> class JSDOMWrapper : public JSDOMObject {

public:

    typedef JSDOMObject Base;

Source/WebCore/bindings/js/WebCoreJSClientData.cpp

#include "WebCoreJSClientData.h"

#include "DOMGCOutputConstraint.h"

30#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMBuiltinConstructorBase.h"

#include "JSDOMWindow.h"

@@JSVMClientData::JSVMClientData(VM& vm)

    , m_runtimeMethodSpace ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), RuntimeMethod) // Hash:0xf70c4a85

    , m_runtimeObjectSpace ISO_SUBSPACE_INIT(vm.heap, m_runtimeObjectHeapCellType.get(), JSC::Bindings::RuntimeObject)

    , m_windowProxySpace ISO_SUBSPACE_INIT(vm.heap, m_windowProxyHeapCellType.get(), JSWindowProxy)

    , m_subspaceForJSDOMWindow ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSDOMWindow.get(), JSDOMWindow)

    , m_subspaceForJSDedicatedWorkerGlobalScope ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSDedicatedWorkerGlobalScope.get(), JSDedicatedWorkerGlobalScope)

    , m_subspaceForJSRemoteDOMWindow ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSRemoteDOMWindow.get(), JSRemoteDOMWindow)

    , m_subspaceForJSWorkerGlobalScope ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSWorkerGlobalScope.get(), JSWorkerGlobalScope)

#if ENABLE(SERVICE_WORKER)

    , m_subspaceForJSServiceWorkerGlobalScope ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSServiceWorkerGlobalScope.get(), JSServiceWorkerGlobalScope)

#endif

#if ENABLE(CSS_PAINTING_API)

    , m_subspaceForJSPaintWorkletGlobalScope ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSPaintWorkletGlobalScope.get(), JSPaintWorkletGlobalScope)

    , m_subspaceForJSWorkletGlobalScope ISO_SUBSPACE_INIT(vm.heap, m_heapCellTypeForJSWorkletGlobalScope.get(), JSWorkletGlobalScope)

#endif

    , m_outputConstraintSpace("WebCore Wrapper w/ Output Constraint", vm.heap, vm.destructibleObjectHeapCellType.get(), vm.fastMallocAllocator.get()) // Hash:0x7724c2e4

81 , m_subspaces(makeUnique<DOMIsoSubspaces>())

{

}

Source/WebCore/bindings/js/WebCoreJSClientData.h

namespace WebCore {

32class DOMIsoSubspaces;

33

class JSVMClientData : public JSC::VM::ClientData {

    WTF_MAKE_NONCOPYABLE(JSVMClientData); WTF_MAKE_FAST_ALLOCATED;

    friend class VMWorldIterator;

@@class JSVMClientData : public JSC::VM::ClientData {

    JSC::IsoSubspace& runtimeObjectSpace() { return m_runtimeObjectSpace; }

    JSC::IsoSubspace& windowProxySpace() { return m_windowProxySpace; }

70 JSC::C~~omplete~~Subspace& outputConstraintSpace() { return m_outputConstraintSpace; }

72 Vector<JSC::IsoSubspace*> outputConstraintSpaces() { return m_outputConstraintSpaces; }

7173

    JSC::IsoSubspace& subspaceForJSDOMWindow() { return m_subspaceForJSDOMWindow; }

    JSC::IsoSubspace& subspaceForJSDedicatedWorkerGlobalScope() { return m_subspaceForJSDedicatedWorkerGlobalScope; }

    JSC::IsoSubspace& subspaceForJSRemoteDOMWindow() { return m_subspaceForJSRemoteDOMWindow; }

    JSC::IsoSubspace& subspaceForJSWorkerGlobalScope() { return m_subspaceForJSWorkerGlobalScope; }

#if ENABLE(SERVICE_WORKER)

    JSC::IsoSubspace& subspaceForJSServiceWorkerGlobalScope() { return m_subspaceForJSServiceWorkerGlobalScope; }

#endif

#if ENABLE(CSS_PAINTING_API)

    JSC::IsoSubspace& subspaceForJSPaintWorkletGlobalScope() { return m_subspaceForJSPaintWorkletGlobalScope; }

    JSC::IsoSubspace& subspaceForJSWorkletGlobalScope() { return m_subspaceForJSWorkletGlobalScope; }

#endif

    template<typename Func>

    void forEachOutputConstraintSpace(const Func& func)

    {

        func(m_outputConstraintSpace);

        func(m_subspaceForJSDOMWindow);

        func(m_subspaceForJSDedicatedWorkerGlobalScope);

        func(m_subspaceForJSRemoteDOMWindow);

        func(m_subspaceForJSWorkerGlobalScope);

#if ENABLE(SERVICE_WORKER)

        func(m_subspaceForJSServiceWorkerGlobalScope);

#endif

#if ENABLE(CSS_PAINTING_API)

        func(m_subspaceForJSPaintWorkletGlobalScope);

        func(m_subspaceForJSWorkletGlobalScope);

#endif

77 for (auto* space : m_outputConstraintSpaces)

78 func(*space);

9979 }

10080

81 DOMIsoSubspaces& subspaces() { return *m_subspaces.get(); }

82

private:

    HashSet<DOMWrapperWorld*> m_worldSet;

    RefPtr<DOMWrapperWorld> m_normalWorld;

@@class JSVMClientData : public JSC::VM::ClientData {

    std::unique_ptr<JSC::HeapCellType> m_runtimeArrayHeapCellType;

    std::unique_ptr<JSC::HeapCellType> m_runtimeObjectHeapCellType;

    std::unique_ptr<JSC::HeapCellType> m_windowProxyHeapCellType;

111

93public:

    std::unique_ptr<JSC::HeapCellType> m_heapCellTypeForJSDOMWindow;

    std::unique_ptr<JSC::HeapCellType> m_heapCellTypeForJSDedicatedWorkerGlobalScope;

    std::unique_ptr<JSC::HeapCellType> m_heapCellTypeForJSRemoteDOMWindow;

@@class JSVMClientData : public JSC::VM::ClientData {

    std::unique_ptr<JSC::HeapCellType> m_heapCellTypeForJSPaintWorkletGlobalScope;

    std::unique_ptr<JSC::HeapCellType> m_heapCellTypeForJSWorkletGlobalScope;

#endif

123

105private:

    JSC::IsoSubspace m_domBuiltinConstructorSpace;

    JSC::IsoSubspace m_domConstructorSpace;

    JSC::IsoSubspace m_domWindowPropertiesSpace;

@@class JSVMClientData : public JSC::VM::ClientData {

    JSC::IsoSubspace m_runtimeMethodSpace;

    JSC::IsoSubspace m_runtimeObjectSpace;

    JSC::IsoSubspace m_windowProxySpace;

    JSC::IsoSubspace m_subspaceForJSDOMWindow;

    JSC::IsoSubspace m_subspaceForJSDedicatedWorkerGlobalScope;

    JSC::IsoSubspace m_subspaceForJSRemoteDOMWindow;

    JSC::IsoSubspace m_subspaceForJSWorkerGlobalScope;

#if ENABLE(SERVICE_WORKER)

    JSC::IsoSubspace m_subspaceForJSServiceWorkerGlobalScope;

#endif

#if ENABLE(CSS_PAINTING_API)

    JSC::IsoSubspace m_subspaceForJSPaintWorkletGlobalScope;

    JSC::IsoSubspace m_subspaceForJSWorkletGlobalScope;

#endif

    JSC::CompleteSubspace m_outputConstraintSpace;

113 std::unique_ptr<DOMIsoSubspaces> m_subspaces;

114 Vector<JSC::IsoSubspace*> m_outputConstraintSpaces;

};

} // namespace WebCore

Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

@@sub GenerateHeader

        }

    }

    # FIXME: We put this unconditionally to put all the WebCore JS wrappers in each IsoSubspace.

    # https://bugs.webkit.org/show_bug.cgi?id=205107

    if (IsDOMGlobalObject($interface)) {

        push(@headerContent, "    template<typename, JSC::SubspaceAccess> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm) { return subspaceForImpl(vm); }\n");

        push(@headerContent, "    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);\n");

    }

    push(@headerContent, "    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)\n");

    push(@headerContent, "    {\n");

    push(@headerContent, "        if constexpr (mode == JSC::SubspaceAccess::Concurrently)\n");

    push(@headerContent, "            return nullptr;\n");

    push(@headerContent, "        return subspaceForImpl(vm);\n");

    push(@headerContent, "    }\n");

    push(@headerContent, "    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);\n");

    # visit function

    if ($needsVisitChildren) {

@@sub GenerateHeader

            # program resumed since the last call to visitChildren or visitOutputConstraints. Since

            # this just calls visitAdditionalChildren, you usually don't have to worry about this.

            push(@headerContent, "    static void visitOutputConstraints(JSCell*, JSC::SlotVisitor&);\n");

            if (!IsDOMGlobalObject($interface)) {

                push(@headerContent, "    template<typename, JSC::SubspaceAccess> static JSC::CompleteSubspace* subspaceFor(JSC::VM& vm) { return outputConstraintSubspaceFor(vm); }\n");

            }

        }

    }

@@sub GenerateImplementation

    GenerateIterableDefinition($interface) if $interface->iterable;

    GenerateSerializerDefinition($interface, $className) if $interface->serializable;

    AddToImplIncludes("DOMIsoSubspaces.h");

    AddToImplIncludes("WebCoreJSClientData.h");

    AddToImplIncludes("<JavaScriptCore/JSDestructibleObjectHeapCellType.h>");

    AddToImplIncludes("<JavaScriptCore/SubspaceInlines.h>");

    push(@implContent, "JSC::IsoSubspace* ${className}::subspaceForImpl(JSC::VM& vm)\n");

    push(@implContent, "{\n");

    push(@implContent, "    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);\n");

    push(@implContent, "    auto& spaces = clientData.subspaces();\n");

    push(@implContent, "    if (auto* space = spaces.m_subspaceFor${interfaceName}.get())\n");

    push(@implContent, "        return space;\n");

46654673 if (IsDOMGlobalObject($interface)) {

        AddToImplIncludes("WebCoreJSClientData.h");

        push(@implContent, "JSC::IsoSubspace* ${className}::subspaceForImpl(JSC::VM& vm)\n");

        push(@implContent, "{\n");

        push(@implContent, "    return &static_cast<JSVMClientData*>(vm.clientData)->subspaceFor${className}();\n");

        push(@implContent, "}\n\n");

    }

        push(@implContent, "    spaces.m_subspaceFor${interfaceName} = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, clientData.m_heapCellTypeFor${className}.get(), ${className});\n");

    } else {

        push(@implContent, "    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, ${className}>)\n");

        push(@implContent, "        spaces.m_subspaceFor${interfaceName} = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), ${className});\n");

        push(@implContent, "    else\n");

        push(@implContent, "        spaces.m_subspaceFor${interfaceName} = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), ${className});\n");

    }

    push(@implContent, "    auto* space = spaces.m_subspaceFor${interfaceName}.get();\n");

    push(@implContent, "IGNORE_WARNINGS_BEGIN(\"unreachable-code\")\n");

    push(@implContent, "IGNORE_WARNINGS_BEGIN(\"tautological-compare\")\n");

    push(@implContent, "    if (&${className}::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)\n");

    push(@implContent, "        clientData.outputConstraintSpaces().append(space);\n");

    push(@implContent, "IGNORE_WARNINGS_END\n");

    push(@implContent, "IGNORE_WARNINGS_END\n");

    push(@implContent, "    return space;\n");

    push(@implContent, "}\n\n");

    if ($needsVisitChildren) {

        push(@implContent, "void ${className}::visitChildren(JSCell* cell, SlotVisitor& visitor)\n");

Source/WebCore/bindings/scripts/generate-bindings-all.pl

my @idlDirectories;

my $outputDirectory;

my $idlFilesList;

41my $ppIDLFilesList;

my $generator;

my @generatorDependency;

my $defines;

GetOptions('include=s@' => \@idlDirectories,

           'outputDir=s' => \$outputDirectory,

           'idlFilesList=s' => \$idlFilesList,

56 'ppIDLFilesList=s' => \$ppIDLFilesList,

           'generator=s' => \$generator,

           'generatorDependency=s@' => \@generatorDependency,

           'defines=s' => \$defines,

@idlFiles = map { CygwinPathIfNeeded(s/\r?\n?$//r) } <$fh>;

close($fh) or die;

my @ppIDLFiles;

open(my $fh, '<', $ppIDLFilesList) or die "Cannot open $ppIDLFilesList";

@ppIDLFiles = map { CygwinPathIfNeeded(s/\r?\n?$//r) } <$fh>;

close($fh) or die;

my %oldSupplements;

my %newSupplements;

if ($supplementalDependencyFile) {

    my @output = ($supplementalDependencyFile, @ppExtraOutput);

76 my @deps = ($~~idl~~FilesList, @~~idl~~Files, @generatorDependency);

83 my @deps = ($ppIDLFilesList, @ppIDLFiles, @generatorDependency);

    if (needsUpdate(\@output, \@deps)) {

        readSupplementalDependencyFile($supplementalDependencyFile, \%oldSupplements) if -e $supplementalDependencyFile;

        my @args = (File::Spec->catfile($scriptDir, 'preprocess-idls.pl'),

                    '--defines', $defines,

81 '--idlFilesList', $~~idl~~FilesList,

88 '--idlFilesList', $ppIDLFilesList,

                    '--supplementalDependencyFile', $supplementalDependencyFile,

                    @ppExtraArgs);

        printProgress("Preprocess IDL");

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

my $idlFilesList;

my $testGlobalContextName;

my $supplementalDependencyFile;

36my $isoSubspacesHeaderFile;

my $windowConstructorsFile;

my $workerGlobalScopeConstructorsFile;

my $dedicatedWorkerGlobalScopeConstructorsFile;

           'idlFilesList=s' => \$idlFilesList,

           'testGlobalContextName=s' => \$testGlobalContextName,

           'supplementalDependencyFile=s' => \$supplementalDependencyFile,

51 'isoSubspacesHeaderFile=s' => \$isoSubspacesHeaderFile,

           'windowConstructorsFile=s' => \$windowConstructorsFile,

           'workerGlobalScopeConstructorsFile=s' => \$workerGlobalScopeConstructorsFile,

           'dedicatedWorkerGlobalScopeConstructorsFile=s' => \$dedicatedWorkerGlobalScopeConstructorsFile,

die('Must specify the file listing all IDLs using --idlFilesList.') unless defined($idlFilesList);

$supplementalDependencyFile = CygwinPathIfNeeded($supplementalDependencyFile);

73$isoSubspacesHeaderFile = CygwinPathIfNeeded($isoSubspacesHeaderFile);

$windowConstructorsFile = CygwinPathIfNeeded($windowConstructorsFile);

$workerGlobalScopeConstructorsFile = CygwinPathIfNeeded($workerGlobalScopeConstructorsFile);

$dedicatedWorkerGlobalScopeConstructorsFile = CygwinPathIfNeeded($dedicatedWorkerGlobalScopeConstructorsFile);

my $paintWorkletGlobalScopeConstructorsCode = "";

my $testGlobalScopeConstructorsCode = "";

my $isoSubspacesHeaderCode = <<END;

#include <wtf/FastMalloc.h>

#include <wtf/Noncopyable.h>

#pragma once

namespace WebCore {

class DOMIsoSubspaces {

    WTF_MAKE_NONCOPYABLE(DOMIsoSubspaces);

    WTF_MAKE_FAST_ALLOCATED(DOMIsoSubspaces);

public:

    DOMIsoSubspaces() = default;

END

# Get rid of duplicates in idlFiles array.

my %idlFileHash = map { $_, 1 } @idlFiles;

        }

    }

    if (!isCallbackInterfaceFromIDL($idlFileContents)) {

        $isoSubspacesHeaderCode .= "    std::unique_ptr<JSC::IsoSubspace> m_subspaceFor${interfaceName};\n"

    }

    # For every interface that is exposed in a given ECMAScript global environment and:

    # - is a callback interface that has constants declared on it, or

    # - is a non-callback interface that is not declared with the [NoInterfaceObject] extended attribute, a corresponding

    delete $supplementals{$idlFile};

}

if ($isoSubspacesHeaderFile) {

    $isoSubspacesHeaderCode .= "};\n";

    $isoSubspacesHeaderCode .= "} // namespace WebCore\n";

    WriteFileIfChanged($isoSubspacesHeaderFile, $isoSubspacesHeaderCode);

}

# Outputs the dependency.

# The format of a supplemental dependency file:

#

Source/WebCore/bindings/scripts/test/JS/JSInterfaceName.cpp

#include "JSInterfaceName.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

31#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

35#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

36#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSInterfaceNameConstructor(JSGlobalObject* lexicalGlobalObject, EncodedJ

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSInterfaceName::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForInterfaceName.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSInterfaceName>)

        spaces.m_subspaceForInterfaceName = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSInterfaceName);

    else

        spaces.m_subspaceForInterfaceName = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSInterfaceName);

    auto* space = spaces.m_subspaceForInterfaceName.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSInterfaceName::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSInterfaceName::visitChildren(JSCell* cell, SlotVisitor& visitor)

{

    auto* thisObject = jsCast<JSInterfaceName*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSInterfaceName.h

@@class JSInterfaceName : public JSDOMWrapper<InterfaceName> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void visitChildren(JSCell*, JSC::SlotVisitor&);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

Source/WebCore/bindings/scripts/test/JS/JSMapLike.cpp

#include "JSMapLike.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

36#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

41#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsMapLikePrototypeFunctionDelete(JSGlobalObject* le

    return IDLOperation<JSMapLike>::call<jsMapLikePrototypeFunctionDeleteBody>(*lexicalGlobalObject, *callFrame, "delete");

}

JSC::IsoSubspace* JSMapLike::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForMapLike.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSMapLike>)

        spaces.m_subspaceForMapLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSMapLike);

    else

        spaces.m_subspaceForMapLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSMapLike);

    auto* space = spaces.m_subspaceForMapLike.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSMapLike::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSMapLike::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSMapLike*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSMapLike.h

@@class JSMapLike : public JSDOMWrapper<MapLike> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSMapLike(JSC::Structure*, JSDOMGlobalObject&, Ref<MapLike>&&);

Source/WebCore/bindings/scripts/test/JS/JSReadOnlyMapLike.cpp

#include "JSReadOnlyMapLike.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

36#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

41#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsReadOnlyMapLikePrototypeFunctionForEach(JSGlobalO

    return IDLOperation<JSReadOnlyMapLike>::call<jsReadOnlyMapLikePrototypeFunctionForEachBody>(*lexicalGlobalObject, *callFrame, "forEach");

}

JSC::IsoSubspace* JSReadOnlyMapLike::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForReadOnlyMapLike.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSReadOnlyMapLike>)

        spaces.m_subspaceForReadOnlyMapLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSReadOnlyMapLike);

    else

        spaces.m_subspaceForReadOnlyMapLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSReadOnlyMapLike);

    auto* space = spaces.m_subspaceForReadOnlyMapLike.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSReadOnlyMapLike::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSReadOnlyMapLike::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSReadOnlyMapLike*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSReadOnlyMapLike.h

@@class JSReadOnlyMapLike : public JSDOMWrapper<ReadOnlyMapLike> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSReadOnlyMapLike(JSC::Structure*, JSDOMGlobalObject&, Ref<ReadOnlyMapLike>&&);

Source/WebCore/bindings/scripts/test/JS/JSReadOnlySetLike.cpp

#include "JSReadOnlySetLike.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMSetLike.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

36#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

41#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsReadOnlySetLikePrototypeFunctionForEach(JSGlobalO

    return IDLOperation<JSReadOnlySetLike>::call<jsReadOnlySetLikePrototypeFunctionForEachBody>(*lexicalGlobalObject, *callFrame, "forEach");

}

JSC::IsoSubspace* JSReadOnlySetLike::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForReadOnlySetLike.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSReadOnlySetLike>)

        spaces.m_subspaceForReadOnlySetLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSReadOnlySetLike);

    else

        spaces.m_subspaceForReadOnlySetLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSReadOnlySetLike);

    auto* space = spaces.m_subspaceForReadOnlySetLike.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSReadOnlySetLike::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSReadOnlySetLike::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSReadOnlySetLike*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSReadOnlySetLike.h

@@class JSReadOnlySetLike : public JSDOMWrapper<ReadOnlySetLike> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSReadOnlySetLike(JSC::Structure*, JSDOMGlobalObject&, Ref<ReadOnlySetLike>&&);

Source/WebCore/bindings/scripts/test/JS/JSSetLike.cpp

#include "JSSetLike.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMSetLike.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

36#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

41#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsSetLikePrototypeFunctionDelete(JSGlobalObject* le

    return IDLOperation<JSSetLike>::call<jsSetLikePrototypeFunctionDeleteBody>(*lexicalGlobalObject, *callFrame, "delete");

}

JSC::IsoSubspace* JSSetLike::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForSetLike.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSSetLike>)

        spaces.m_subspaceForSetLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSSetLike);

    else

        spaces.m_subspaceForSetLike = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSSetLike);

    auto* space = spaces.m_subspaceForSetLike.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSSetLike::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSSetLike::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSSetLike*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSSetLike.h

@@class JSSetLike : public JSDOMWrapper<SetLike> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSSetLike(JSC::Structure*, JSDOMGlobalObject&, Ref<SetLike>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestActiveDOMObject.cpp

#include "ActiveDOMObject.h"

#include "CustomElementReactionQueue.h"

26#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMBindingSecurity.h"

#include "JSDOMWrapperCache.h"

#include "JSNode.h"

#include "ScriptExecutionContext.h"

39#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

43#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

44#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestActiveDOMObjectPrototypeFunctionOverloadedMet

    return IDLOperation<JSTestActiveDOMObject>::call<jsTestActiveDOMObjectPrototypeFunctionOverloadedMethodOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "overloadedMethod");

}

JSC::IsoSubspace* JSTestActiveDOMObject::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestActiveDOMObject.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestActiveDOMObject>)

        spaces.m_subspaceForTestActiveDOMObject = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestActiveDOMObject);

    else

        spaces.m_subspaceForTestActiveDOMObject = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestActiveDOMObject);

    auto* space = spaces.m_subspaceForTestActiveDOMObject.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestActiveDOMObject::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestActiveDOMObject::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestActiveDOMObject*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestActiveDOMObject.h

@@class JSTestActiveDOMObject : public JSDOMWrapper<TestActiveDOMObject> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::HasPutPropertySecurityCheck | JSC::HasStaticPropertyTable;

Source/WebCore/bindings/scripts/test/JS/JSTestCEReactions.cpp

#include "ActiveDOMObject.h"

#include "CustomElementReactionQueue.h"

26#include "DOMIsoSubspaces.h"

#include "HTMLNames.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMWrapperCache.h"

#include "JSTestCEReactionsStringifier.h"

#include "ScriptExecutionContext.h"

39#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

43#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

44#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestCEReactionsPrototypeFunctionMethodWithCEReact

    return IDLOperation<JSTestCEReactions>::call<jsTestCEReactionsPrototypeFunctionMethodWithCEReactionsNotNeededBody>(*lexicalGlobalObject, *callFrame, "methodWithCEReactionsNotNeeded");

}

JSC::IsoSubspace* JSTestCEReactions::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestCEReactions.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestCEReactions>)

        spaces.m_subspaceForTestCEReactions = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestCEReactions);

    else

        spaces.m_subspaceForTestCEReactions = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestCEReactions);

    auto* space = spaces.m_subspaceForTestCEReactions.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestCEReactions::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestCEReactions::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestCEReactions*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestCEReactions.h

@@class JSTestCEReactions : public JSDOMWrapper<TestCEReactions> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestCEReactions(JSC::Structure*, JSDOMGlobalObject&, Ref<TestCEReactions>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestCEReactionsStringifier.cpp

#include "ActiveDOMObject.h"

#include "CustomElementReactionQueue.h"

26#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

40#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestCEReactionsStringifierPrototypeFunctionToStri

    return IDLOperation<JSTestCEReactionsStringifier>::call<jsTestCEReactionsStringifierPrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestCEReactionsStringifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestCEReactionsStringifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestCEReactionsStringifier>)

        spaces.m_subspaceForTestCEReactionsStringifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestCEReactionsStringifier);

    else

        spaces.m_subspaceForTestCEReactionsStringifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestCEReactionsStringifier);

    auto* space = spaces.m_subspaceForTestCEReactionsStringifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestCEReactionsStringifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestCEReactionsStringifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestCEReactionsStringifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestCEReactionsStringifier.h

@@class JSTestCEReactionsStringifier : public JSDOMWrapper<TestCEReactionsStringif

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestCEReactionsStringifier(JSC::Structure*, JSDOMGlobalObject&, Ref<TestCEReactionsStringifier>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestCallTracer.cpp

#include "ActiveDOMObject.h"

#include "CallTracer.h"

26#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMWrapperCache.h"

#include "JSNode.h"

#include "ScriptExecutionContext.h"

42#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

46#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

47#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestCallTracerPrototypeFunctionTestOperationWithD

    return IDLOperation<JSTestCallTracer>::call<jsTestCallTracerPrototypeFunctionTestOperationWithDefaultVariantArgumentBody>(*lexicalGlobalObject, *callFrame, "testOperationWithDefaultVariantArgument");

}

JSC::IsoSubspace* JSTestCallTracer::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestCallTracer.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestCallTracer>)

        spaces.m_subspaceForTestCallTracer = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestCallTracer);

    else

        spaces.m_subspaceForTestCallTracer = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestCallTracer);

    auto* space = spaces.m_subspaceForTestCallTracer.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestCallTracer::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestCallTracer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestCallTracer*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestCallTracer.h

@@class JSTestCallTracer : public JSDOMWrapper<TestCallTracer> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestCallTracer(JSC::Structure*, JSDOMGlobalObject&, Ref<TestCallTracer>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestClassWithJSBuiltinConstructor.cpp

#include "JSTestClassWithJSBuiltinConstructor.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMBuiltinConstructor.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

#include "TestClassWithJSBuiltinConstructorBuiltins.h"

32#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

36#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

37#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestClassWithJSBuiltinConstructorConstructor(JSGlobalObject* lexicalGl

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestClassWithJSBuiltinConstructor::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestClassWithJSBuiltinConstructor.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestClassWithJSBuiltinConstructor>)

        spaces.m_subspaceForTestClassWithJSBuiltinConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestClassWithJSBuiltinConstructor);

    else

        spaces.m_subspaceForTestClassWithJSBuiltinConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestClassWithJSBuiltinConstructor);

    auto* space = spaces.m_subspaceForTestClassWithJSBuiltinConstructor.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestClassWithJSBuiltinConstructor::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestClassWithJSBuiltinConstructor::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestClassWithJSBuiltinConstructor*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestClassWithJSBuiltinConstructor.h

@@class JSTestClassWithJSBuiltinConstructor : public JSDOMWrapper<TestClassWithJSB

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestClassWithJSBuiltinConstructor(JSC::Structure*, JSDOMGlobalObject&, Ref<TestClassWithJSBuiltinConstructor>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestDOMJIT.cpp

#include "JSTestDOMJIT.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "DOMJITAbstractHeapRepository.h"

#include "DOMJITIDLConvert.h"

#include "DOMJITIDLType.h"

#include "JSElement.h"

#include "JSNodeList.h"

#include "ScriptExecutionContext.h"

46#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FrameTracers.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

50#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

51#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@JSC::EncodedJSValue JIT_OPERATION jsTestDOMJITPrototypeFunctionGetElementsByName

    return JSValue::encode(toJS<IDLInterface<NodeList>>(*lexicalGlobalObject, *castedThis->globalObject(), impl.getElementsByName(WTFMove(elementName))));

}

JSC::IsoSubspace* JSTestDOMJIT::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestDOMJIT.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestDOMJIT>)

        spaces.m_subspaceForTestDOMJIT = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestDOMJIT);

    else

        spaces.m_subspaceForTestDOMJIT = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestDOMJIT);

    auto* space = spaces.m_subspaceForTestDOMJIT.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestDOMJIT::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestDOMJIT::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestDOMJIT*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestDOMJIT.h

@@class JSTestDOMJIT : public JSNode {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestDOMJIT& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestEnabledBySetting.cpp

#include "JSTestEnabledBySetting.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "Document.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

40#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

41#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestEnabledBySettingPrototypeFunctionEnabledBySet

#endif

JSC::IsoSubspace* JSTestEnabledBySetting::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestEnabledBySetting.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEnabledBySetting>)

        spaces.m_subspaceForTestEnabledBySetting = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestEnabledBySetting);

    else

        spaces.m_subspaceForTestEnabledBySetting = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestEnabledBySetting);

    auto* space = spaces.m_subspaceForTestEnabledBySetting.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestEnabledBySetting::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestEnabledBySetting::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestEnabledBySetting*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestEnabledBySetting.h

@@class JSTestEnabledBySetting : public JSDOMWrapper<TestEnabledBySetting> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::HasStaticPropertyTable;

Source/WebCore/bindings/scripts/test/JS/JSTestEnabledForContext.cpp

#include "JSTestEnabledForContext.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "Document.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

40#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestEnabledForContextTestSubObjEnabledForContextConstructor(JSGlobalOb

    return IDLAttribute<JSTestEnabledForContext>::set<setJSTestEnabledForContextTestSubObjEnabledForContextConstructorSetter>(*lexicalGlobalObject, thisValue, encodedValue, "TestSubObjEnabledForContext");

}

JSC::IsoSubspace* JSTestEnabledForContext::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestEnabledForContext.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEnabledForContext>)

        spaces.m_subspaceForTestEnabledForContext = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestEnabledForContext);

    else

        spaces.m_subspaceForTestEnabledForContext = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestEnabledForContext);

    auto* space = spaces.m_subspaceForTestEnabledForContext.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestEnabledForContext::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestEnabledForContext::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestEnabledForContext*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestEnabledForContext.h

@@class JSTestEnabledForContext : public JSDOMWrapper<TestEnabledForContext> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::HasStaticPropertyTable;

Source/WebCore/bindings/scripts/test/JS/JSTestEventConstructor.cpp

#include "JSTestEventConstructor.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructor.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

3436#include <JavaScriptCore/HeapAnalyzer.h>

3537#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue jsTestEventConstructorAttr3(JSGlobalObject* lexicalGlobalObject,

#endif

JSC::IsoSubspace* JSTestEventConstructor::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestEventConstructor.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEventConstructor>)

        spaces.m_subspaceForTestEventConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestEventConstructor);

    else

        spaces.m_subspaceForTestEventConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestEventConstructor);

    auto* space = spaces.m_subspaceForTestEventConstructor.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestEventConstructor::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestEventConstructor::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestEventConstructor*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestEventConstructor.h

@@class JSTestEventConstructor : public JSEvent {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestEventConstructor& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestEventTarget.cpp

#include "JSTestEventTarget.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMWrapperCache.h"

#include "JSNode.h"

#include "ScriptExecutionContext.h"

37#include "WebCoreJSClientData.h"

3638#include <JavaScriptCore/HeapAnalyzer.h>

3739#include <JavaScriptCore/JSCInlines.h>

40#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3841#include <JavaScriptCore/PropertyNameArray.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionItem(JSGlobalObje

    return IDLOperation<JSTestEventTarget>::call<jsTestEventTargetPrototypeFunctionItemBody>(*lexicalGlobalObject, *callFrame, "item");

}

JSC::IsoSubspace* JSTestEventTarget::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestEventTarget.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestEventTarget>)

        spaces.m_subspaceForTestEventTarget = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestEventTarget);

    else

        spaces.m_subspaceForTestEventTarget = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestEventTarget);

    auto* space = spaces.m_subspaceForTestEventTarget.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestEventTarget::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestEventTarget::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestEventTarget*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestEventTarget.h

@@class JSTestEventTarget : public JSEventTarget {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestEventTarget& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestException.cpp

#include "JSTestException.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue jsTestExceptionName(JSGlobalObject* lexicalGlobalObject, EncodedJ

    return IDLAttribute<JSTestException>::get<jsTestExceptionNameGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "name");

}

JSC::IsoSubspace* JSTestException::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestException.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestException>)

        spaces.m_subspaceForTestException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestException);

    else

        spaces.m_subspaceForTestException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestException);

    auto* space = spaces.m_subspaceForTestException.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestException::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestException::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestException*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestException.h

@@class JSTestException : public JSDOMWrapper<TestException> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestException(JSC::Structure*, JSDOMGlobalObject&, Ref<TestException>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp

#include "JSTestGenerateIsReachable.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue jsTestGenerateIsReachableASecretAttribute(JSGlobalObject* lexical

    return IDLAttribute<JSTestGenerateIsReachable>::get<jsTestGenerateIsReachableASecretAttributeGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "aSecretAttribute");

}

JSC::IsoSubspace* JSTestGenerateIsReachable::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestGenerateIsReachable.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestGenerateIsReachable>)

        spaces.m_subspaceForTestGenerateIsReachable = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestGenerateIsReachable);

    else

        spaces.m_subspaceForTestGenerateIsReachable = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestGenerateIsReachable);

    auto* space = spaces.m_subspaceForTestGenerateIsReachable.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestGenerateIsReachable::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestGenerateIsReachable::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestGenerateIsReachable*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.h

@@class JSTestGenerateIsReachable : public JSDOMWrapper<TestGenerateIsReachable> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestGenerateIsReachable(JSC::Structure*, JSDOMGlobalObject&, Ref<TestGenerateIsReachable>&&);

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

#include "JSTestGlobalObject.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "DOMWrapperWorld.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

104#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

105#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionTestFeatureGetSec

JSC::IsoSubspace* JSTestGlobalObject::subspaceForImpl(JSC::VM& vm)

{

2782 return &static_cast<JSVMClientData*>(vm.clientData)->subspaceForJSTestGlobalObject();

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestGlobalObject.get())

        return space;

    spaces.m_subspaceForTestGlobalObject = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, clientData.m_heapCellTypeForJSTestGlobalObject.get(), JSTestGlobalObject);

    auto* space = spaces.m_subspaceForTestGlobalObject.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestGlobalObject::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestGlobalObject::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

Source/WebCore/bindings/scripts/test/JS/JSTestGlobalObject.h

@@class JSTestGlobalObject : public JSDOMWrapper<TestGlobalObject> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

52 template<typename, JSC::SubspaceAccess> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm) { return subspaceForImpl(vm); }

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterNoIdentifier.cpp

#include "JSTestIndexedSetterNoIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

32#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

36#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3437#include <JavaScriptCore/PropertyNameArray.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestIndexedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobal

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestIndexedSetterNoIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestIndexedSetterNoIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterNoIdentifier>)

        spaces.m_subspaceForTestIndexedSetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestIndexedSetterNoIdentifier);

    else

        spaces.m_subspaceForTestIndexedSetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestIndexedSetterNoIdentifier);

    auto* space = spaces.m_subspaceForTestIndexedSetterNoIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestIndexedSetterNoIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestIndexedSetterNoIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestIndexedSetterNoIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterNoIdentifier.h

@@class JSTestIndexedSetterNoIdentifier : public JSDOMWrapper<TestIndexedSetterNoI

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterThrowingException.cpp

#include "JSTestIndexedSetterThrowingException.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

32#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

36#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3437#include <JavaScriptCore/PropertyNameArray.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestIndexedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalG

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestIndexedSetterThrowingException::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestIndexedSetterThrowingException.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterThrowingException>)

        spaces.m_subspaceForTestIndexedSetterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestIndexedSetterThrowingException);

    else

        spaces.m_subspaceForTestIndexedSetterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestIndexedSetterThrowingException);

    auto* space = spaces.m_subspaceForTestIndexedSetterThrowingException.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestIndexedSetterThrowingException::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestIndexedSetterThrowingException::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestIndexedSetterThrowingException*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterThrowingException.h

@@class JSTestIndexedSetterThrowingException : public JSDOMWrapper<TestIndexedSett

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterWithIdentifier.cpp

#include "JSTestIndexedSetterWithIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertNumbers.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3639#include <JavaScriptCore/PropertyNameArray.h>

40#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestIndexedSetterWithIdentifierPrototypeFunctionI

    return IDLOperation<JSTestIndexedSetterWithIdentifier>::call<jsTestIndexedSetterWithIdentifierPrototypeFunctionIndexedSetterBody>(*lexicalGlobalObject, *callFrame, "indexedSetter");

}

JSC::IsoSubspace* JSTestIndexedSetterWithIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestIndexedSetterWithIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIndexedSetterWithIdentifier>)

        spaces.m_subspaceForTestIndexedSetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestIndexedSetterWithIdentifier);

    else

        spaces.m_subspaceForTestIndexedSetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestIndexedSetterWithIdentifier);

    auto* space = spaces.m_subspaceForTestIndexedSetterWithIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestIndexedSetterWithIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestIndexedSetterWithIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestIndexedSetterWithIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestIndexedSetterWithIdentifier.h

@@class JSTestIndexedSetterWithIdentifier : public JSDOMWrapper<TestIndexedSetterW

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp

#include "JSTestInterface.h"

#include "ActiveDOMObject.h"

28#include "DOMIsoSubspaces.h"

#include "HTMLNames.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSTestObj.h"

#include "ScriptExecutionContext.h"

#include "TestSupplemental.h"

42#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

47#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

48#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@JSC::EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionForEach(JSC::J

    return IDLOperation<JSTestInterface>::call<jsTestInterfacePrototypeFunctionForEachCaller>(*lexicalGlobalObject, *callFrame, "forEach");

}

JSC::IsoSubspace* JSTestInterface::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestInterface.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestInterface>)

        spaces.m_subspaceForTestInterface = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestInterface);

    else

        spaces.m_subspaceForTestInterface = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestInterface);

    auto* space = spaces.m_subspaceForTestInterface.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestInterface::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestInterface::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestInterface*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestInterface.h

@@class WEBCORE_EXPORT JSTestInterface : public JSDOMWrapper<TestInterface> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    // Custom attributes

Source/WebCore/bindings/scripts/test/JS/JSTestInterfaceLeadingUnderscore.cpp

#include "JSTestInterfaceLeadingUnderscore.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue jsTestInterfaceLeadingUnderscoreReadonly(JSGlobalObject* lexicalG

    return IDLAttribute<JSTestInterfaceLeadingUnderscore>::get<jsTestInterfaceLeadingUnderscoreReadonlyGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "readonly");

}

JSC::IsoSubspace* JSTestInterfaceLeadingUnderscore::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestInterfaceLeadingUnderscore.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestInterfaceLeadingUnderscore>)

        spaces.m_subspaceForTestInterfaceLeadingUnderscore = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestInterfaceLeadingUnderscore);

    else

        spaces.m_subspaceForTestInterfaceLeadingUnderscore = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestInterfaceLeadingUnderscore);

    auto* space = spaces.m_subspaceForTestInterfaceLeadingUnderscore.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestInterfaceLeadingUnderscore::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestInterfaceLeadingUnderscore::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestInterfaceLeadingUnderscore*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestInterfaceLeadingUnderscore.h

@@class JSTestInterfaceLeadingUnderscore : public JSDOMWrapper<TestInterfaceLeadin

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestInterfaceLeadingUnderscore(JSC::Structure*, JSDOMGlobalObject&, Ref<TestInterfaceLeadingUnderscore>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestIterable.cpp

#include "JSTestIterable.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertInterface.h"

#include "JSDOMWrapperCache.h"

#include "JSTestNode.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

40#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

41#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@JSC::EncodedJSValue JSC_HOST_CALL jsTestIterablePrototypeFunctionForEach(JSC::JS

    return IDLOperation<JSTestIterable>::call<jsTestIterablePrototypeFunctionForEachCaller>(*lexicalGlobalObject, *callFrame, "forEach");

}

JSC::IsoSubspace* JSTestIterable::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestIterable.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestIterable>)

        spaces.m_subspaceForTestIterable = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestIterable);

    else

        spaces.m_subspaceForTestIterable = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestIterable);

    auto* space = spaces.m_subspaceForTestIterable.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestIterable::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestIterable::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestIterable*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestIterable.h

@@class JSTestIterable : public JSDOMWrapper<TestIterable> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestIterable(JSC::Structure*, JSDOMGlobalObject&, Ref<TestIterable>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestJSBuiltinConstructor.cpp

#include "config.h"

#include "JSTestJSBuiltinConstructor.h"

24#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMBuiltinConstructor.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "TestJSBuiltinConstructorBuiltins.h"

32#include "WebCoreJSClientData.h"

3133#include <JavaScriptCore/FunctionPrototype.h>

3234#include <JavaScriptCore/JSCInlines.h>

35#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

36#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

@@EncodedJSValue JSC_HOST_CALL jsTestJSBuiltinConstructorPrototypeFunctionTestCust

    return IDLOperation<JSTestJSBuiltinConstructor>::call<jsTestJSBuiltinConstructorPrototypeFunctionTestCustomFunctionBody>(*lexicalGlobalObject, *callFrame, "testCustomFunction");

}

JSC::IsoSubspace* JSTestJSBuiltinConstructor::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestJSBuiltinConstructor.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestJSBuiltinConstructor>)

        spaces.m_subspaceForTestJSBuiltinConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestJSBuiltinConstructor);

    else

        spaces.m_subspaceForTestJSBuiltinConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestJSBuiltinConstructor);

    auto* space = spaces.m_subspaceForTestJSBuiltinConstructor.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestJSBuiltinConstructor::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

236260

237261}

Source/WebCore/bindings/scripts/test/JS/JSTestJSBuiltinConstructor.h

@@class JSTestJSBuiltinConstructor : public JSDOMObject {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    // Custom attributes

    JSC::JSValue testAttributeCustom(JSC::JSGlobalObject&) const;

Source/WebCore/bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp

#include "JSTestMediaQueryListListener.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertCallbacks.h"

#include "JSDOMWrapperCache.h"

#include "JSMediaQueryListListener.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

40#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestMediaQueryListListenerPrototypeFunctionMethod

    return IDLOperation<JSTestMediaQueryListListener>::call<jsTestMediaQueryListListenerPrototypeFunctionMethodBody>(*lexicalGlobalObject, *callFrame, "method");

}

JSC::IsoSubspace* JSTestMediaQueryListListener::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestMediaQueryListListener.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestMediaQueryListListener>)

        spaces.m_subspaceForTestMediaQueryListListener = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestMediaQueryListListener);

    else

        spaces.m_subspaceForTestMediaQueryListListener = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestMediaQueryListListener);

    auto* space = spaces.m_subspaceForTestMediaQueryListListener.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestMediaQueryListListener::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestMediaQueryListListener::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestMediaQueryListListener*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestMediaQueryListListener.h

@@class JSTestMediaQueryListListener : public JSDOMWrapper<TestMediaQueryListListe

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestMediaQueryListListener(JSC::Structure*, JSDOMGlobalObject&, Ref<TestMediaQueryListListener>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterNoIdentifier.cpp

#include "JSTestNamedAndIndexedSetterNoIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3538#include <JavaScriptCore/PropertyNameArray.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedAndIndexedSetterNoIdentifierConstructor(JSGlobalObject* lexic

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedAndIndexedSetterNoIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterNoIdentifier>)

        spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedAndIndexedSetterNoIdentifier);

    else

        spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedAndIndexedSetterNoIdentifier);

    auto* space = spaces.m_subspaceForTestNamedAndIndexedSetterNoIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedAndIndexedSetterNoIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedAndIndexedSetterNoIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedAndIndexedSetterNoIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterNoIdentifier.h

@@class JSTestNamedAndIndexedSetterNoIdentifier : public JSDOMWrapper<TestNamedAnd

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterThrowingException.cpp

#include "JSTestNamedAndIndexedSetterThrowingException.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3538#include <JavaScriptCore/PropertyNameArray.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedAndIndexedSetterThrowingExceptionConstructor(JSGlobalObject*

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedAndIndexedSetterThrowingException::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterThrowingException>)

        spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedAndIndexedSetterThrowingException);

    else

        spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedAndIndexedSetterThrowingException);

    auto* space = spaces.m_subspaceForTestNamedAndIndexedSetterThrowingException.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedAndIndexedSetterThrowingException::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedAndIndexedSetterThrowingException::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedAndIndexedSetterThrowingException*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterThrowingException.h

@@class JSTestNamedAndIndexedSetterThrowingException : public JSDOMWrapper<TestNam

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterWithIdentifier.cpp

#include "JSTestNamedAndIndexedSetterWithIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3740#include <JavaScriptCore/PropertyNameArray.h>

41#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedAndIndexedSetterWithIdentifierPrototypeF

    return IDLOperation<JSTestNamedAndIndexedSetterWithIdentifier>::call<jsTestNamedAndIndexedSetterWithIdentifierPrototypeFunctionIndexedSetterBody>(*lexicalGlobalObject, *callFrame, "indexedSetter");

}

JSC::IsoSubspace* JSTestNamedAndIndexedSetterWithIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedAndIndexedSetterWithIdentifier>)

        spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedAndIndexedSetterWithIdentifier);

    else

        spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedAndIndexedSetterWithIdentifier);

    auto* space = spaces.m_subspaceForTestNamedAndIndexedSetterWithIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedAndIndexedSetterWithIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedAndIndexedSetterWithIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedAndIndexedSetterWithIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedAndIndexedSetterWithIdentifier.h

@@class JSTestNamedAndIndexedSetterWithIdentifier : public JSDOMWrapper<TestNamedA

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedConstructor.cpp

#include "JSTestNamedConstructor.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertInterface.h"

#include "JSDOMNamedConstructor.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedConstructorConstructor(JSGlobalObject* lexicalGlobalObject, E

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedConstructor::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedConstructor.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedConstructor>)

        spaces.m_subspaceForTestNamedConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedConstructor);

    else

        spaces.m_subspaceForTestNamedConstructor = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedConstructor);

    auto* space = spaces.m_subspaceForTestNamedConstructor.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedConstructor::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedConstructor::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedConstructor*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedConstructor.h

@@class JSTestNamedConstructor : public JSDOMWrapper<TestNamedConstructor> {

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    static JSC::JSValue getNamedConstructor(JSC::VM&, JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestNamedConstructor(JSC::Structure*, JSDOMGlobalObject&, Ref<TestNamedConstructor>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterNoIdentifier.cpp

#include "JSTestNamedDeleterNoIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedDeleterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalO

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedDeleterNoIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedDeleterNoIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterNoIdentifier>)

        spaces.m_subspaceForTestNamedDeleterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedDeleterNoIdentifier);

    else

        spaces.m_subspaceForTestNamedDeleterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedDeleterNoIdentifier);

    auto* space = spaces.m_subspaceForTestNamedDeleterNoIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedDeleterNoIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedDeleterNoIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedDeleterNoIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterNoIdentifier.h

@@class JSTestNamedDeleterNoIdentifier : public JSDOMWrapper<TestNamedDeleterNoIde

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterThrowingException.cpp

#include "JSTestNamedDeleterThrowingException.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedDeleterThrowingExceptionConstructor(JSGlobalObject* lexicalGl

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedDeleterThrowingException::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedDeleterThrowingException.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterThrowingException>)

        spaces.m_subspaceForTestNamedDeleterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedDeleterThrowingException);

    else

        spaces.m_subspaceForTestNamedDeleterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedDeleterThrowingException);

    auto* space = spaces.m_subspaceForTestNamedDeleterThrowingException.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedDeleterThrowingException::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedDeleterThrowingException::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedDeleterThrowingException*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterThrowingException.h

@@class JSTestNamedDeleterThrowingException : public JSDOMWrapper<TestNamedDeleter

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterWithIdentifier.cpp

#include "JSTestNamedDeleterWithIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedDeleterWithIdentifierPrototypeFunctionNa

    return IDLOperation<JSTestNamedDeleterWithIdentifier>::call<jsTestNamedDeleterWithIdentifierPrototypeFunctionNamedDeleterBody>(*lexicalGlobalObject, *callFrame, "namedDeleter");

}

JSC::IsoSubspace* JSTestNamedDeleterWithIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedDeleterWithIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterWithIdentifier>)

        spaces.m_subspaceForTestNamedDeleterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedDeleterWithIdentifier);

    else

        spaces.m_subspaceForTestNamedDeleterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedDeleterWithIdentifier);

    auto* space = spaces.m_subspaceForTestNamedDeleterWithIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedDeleterWithIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedDeleterWithIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedDeleterWithIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterWithIdentifier.h

@@class JSTestNamedDeleterWithIdentifier : public JSDOMWrapper<TestNamedDeleterWit

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterWithIndexedGetter.cpp

#include "JSTestNamedDeleterWithIndexedGetter.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3538#include <JavaScriptCore/PropertyNameArray.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedDeleterWithIndexedGetterConstructor(JSGlobalObject* lexicalGl

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedDeleterWithIndexedGetter::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedDeleterWithIndexedGetter.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedDeleterWithIndexedGetter>)

        spaces.m_subspaceForTestNamedDeleterWithIndexedGetter = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedDeleterWithIndexedGetter);

    else

        spaces.m_subspaceForTestNamedDeleterWithIndexedGetter = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedDeleterWithIndexedGetter);

    auto* space = spaces.m_subspaceForTestNamedDeleterWithIndexedGetter.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedDeleterWithIndexedGetter::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedDeleterWithIndexedGetter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedDeleterWithIndexedGetter*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedDeleterWithIndexedGetter.h

@@class JSTestNamedDeleterWithIndexedGetter : public JSDOMWrapper<TestNamedDeleter

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterCallWith.cpp

#include "JSTestNamedGetterCallWith.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedGetterCallWithConstructor(JSGlobalObject* lexicalGlobalObject

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedGetterCallWith::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedGetterCallWith.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterCallWith>)

        spaces.m_subspaceForTestNamedGetterCallWith = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedGetterCallWith);

    else

        spaces.m_subspaceForTestNamedGetterCallWith = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedGetterCallWith);

    auto* space = spaces.m_subspaceForTestNamedGetterCallWith.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedGetterCallWith::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedGetterCallWith::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedGetterCallWith*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterCallWith.h

@@class JSTestNamedGetterCallWith : public JSDOMWrapper<TestNamedGetterCallWith> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterNoIdentifier.cpp

#include "JSTestNamedGetterNoIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedGetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalOb

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedGetterNoIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedGetterNoIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterNoIdentifier>)

        spaces.m_subspaceForTestNamedGetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedGetterNoIdentifier);

    else

        spaces.m_subspaceForTestNamedGetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedGetterNoIdentifier);

    auto* space = spaces.m_subspaceForTestNamedGetterNoIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedGetterNoIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedGetterNoIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedGetterNoIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterNoIdentifier.h

@@class JSTestNamedGetterNoIdentifier : public JSDOMWrapper<TestNamedGetterNoIdent

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterWithIdentifier.cpp

#include "JSTestNamedGetterWithIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedGetterWithIdentifierPrototypeFunctionGet

    return IDLOperation<JSTestNamedGetterWithIdentifier>::call<jsTestNamedGetterWithIdentifierPrototypeFunctionGetterNameBody>(*lexicalGlobalObject, *callFrame, "getterName");

}

JSC::IsoSubspace* JSTestNamedGetterWithIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedGetterWithIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedGetterWithIdentifier>)

        spaces.m_subspaceForTestNamedGetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedGetterWithIdentifier);

    else

        spaces.m_subspaceForTestNamedGetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedGetterWithIdentifier);

    auto* space = spaces.m_subspaceForTestNamedGetterWithIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedGetterWithIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedGetterWithIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedGetterWithIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedGetterWithIdentifier.h

@@class JSTestNamedGetterWithIdentifier : public JSDOMWrapper<TestNamedGetterWithI

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterNoIdentifier.cpp

#include "JSTestNamedSetterNoIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedSetterNoIdentifierConstructor(JSGlobalObject* lexicalGlobalOb

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedSetterNoIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterNoIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterNoIdentifier>)

        spaces.m_subspaceForTestNamedSetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterNoIdentifier);

    else

        spaces.m_subspaceForTestNamedSetterNoIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterNoIdentifier);

    auto* space = spaces.m_subspaceForTestNamedSetterNoIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterNoIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterNoIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterNoIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterNoIdentifier.h

@@class JSTestNamedSetterNoIdentifier : public JSDOMWrapper<TestNamedSetterNoIdent

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterThrowingException.cpp

#include "JSTestNamedSetterThrowingException.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedSetterThrowingExceptionConstructor(JSGlobalObject* lexicalGlo

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedSetterThrowingException::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterThrowingException.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterThrowingException>)

        spaces.m_subspaceForTestNamedSetterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterThrowingException);

    else

        spaces.m_subspaceForTestNamedSetterThrowingException = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterThrowingException);

    auto* space = spaces.m_subspaceForTestNamedSetterThrowingException.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterThrowingException::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterThrowingException::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterThrowingException*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterThrowingException.h

@@class JSTestNamedSetterThrowingException : public JSDOMWrapper<TestNamedSetterTh

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIdentifier.cpp

#include "JSTestNamedSetterWithIdentifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithIdentifierPrototypeFunctionNam

    return IDLOperation<JSTestNamedSetterWithIdentifier>::call<jsTestNamedSetterWithIdentifierPrototypeFunctionNamedSetterBody>(*lexicalGlobalObject, *callFrame, "namedSetter");

}

JSC::IsoSubspace* JSTestNamedSetterWithIdentifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterWithIdentifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIdentifier>)

        spaces.m_subspaceForTestNamedSetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterWithIdentifier);

    else

        spaces.m_subspaceForTestNamedSetterWithIdentifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterWithIdentifier);

    auto* space = spaces.m_subspaceForTestNamedSetterWithIdentifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterWithIdentifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterWithIdentifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterWithIdentifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIdentifier.h

@@class JSTestNamedSetterWithIdentifier : public JSDOMWrapper<TestNamedSetterWithI

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetter.cpp

#include "JSTestNamedSetterWithIndexedGetter.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3740#include <JavaScriptCore/PropertyNameArray.h>

41#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithIndexedGetterPrototypeFunction

    return IDLOperation<JSTestNamedSetterWithIndexedGetter>::call<jsTestNamedSetterWithIndexedGetterPrototypeFunctionIndexedSetterBody>(*lexicalGlobalObject, *callFrame, "indexedSetter");

}

JSC::IsoSubspace* JSTestNamedSetterWithIndexedGetter::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterWithIndexedGetter.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIndexedGetter>)

        spaces.m_subspaceForTestNamedSetterWithIndexedGetter = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterWithIndexedGetter);

    else

        spaces.m_subspaceForTestNamedSetterWithIndexedGetter = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterWithIndexedGetter);

    auto* space = spaces.m_subspaceForTestNamedSetterWithIndexedGetter.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterWithIndexedGetter::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterWithIndexedGetter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterWithIndexedGetter*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetter.h

@@class JSTestNamedSetterWithIndexedGetter : public JSDOMWrapper<TestNamedSetterWi

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetterAndSetter.cpp

#include "JSTestNamedSetterWithIndexedGetterAndSetter.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3740#include <JavaScriptCore/PropertyNameArray.h>

41#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithIndexedGetterAndSetterPrototyp

    return IDLOperation<JSTestNamedSetterWithIndexedGetterAndSetter>::call<jsTestNamedSetterWithIndexedGetterAndSetterPrototypeFunctionIndexedSetterOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "indexedSetter");

}

JSC::IsoSubspace* JSTestNamedSetterWithIndexedGetterAndSetter::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithIndexedGetterAndSetter>)

        spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterWithIndexedGetterAndSetter);

    else

        spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterWithIndexedGetterAndSetter);

    auto* space = spaces.m_subspaceForTestNamedSetterWithIndexedGetterAndSetter.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterWithIndexedGetterAndSetter::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterWithIndexedGetterAndSetter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterWithIndexedGetterAndSetter*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithIndexedGetterAndSetter.h

@@class JSTestNamedSetterWithIndexedGetterAndSetter : public JSDOMWrapper<TestName

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithOverrideBuiltins.cpp

#include "JSTestNamedSetterWithOverrideBuiltins.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestNamedSetterWithOverrideBuiltinsConstructor(JSGlobalObject* lexical

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestNamedSetterWithOverrideBuiltins::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterWithOverrideBuiltins.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithOverrideBuiltins>)

        spaces.m_subspaceForTestNamedSetterWithOverrideBuiltins = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterWithOverrideBuiltins);

    else

        spaces.m_subspaceForTestNamedSetterWithOverrideBuiltins = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterWithOverrideBuiltins);

    auto* space = spaces.m_subspaceForTestNamedSetterWithOverrideBuiltins.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterWithOverrideBuiltins::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterWithOverrideBuiltins::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterWithOverrideBuiltins*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithOverrideBuiltins.h

@@class JSTestNamedSetterWithOverrideBuiltins : public JSDOMWrapper<TestNamedSette

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpure | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithUnforgableProperties.cpp

#include "JSTestNamedSetterWithUnforgableProperties.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

40#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithUnforgablePropertiesInstanceFu

    return IDLOperation<JSTestNamedSetterWithUnforgableProperties>::call<jsTestNamedSetterWithUnforgablePropertiesInstanceFunctionUnforgeableOperationBody>(*lexicalGlobalObject, *callFrame, "unforgeableOperation");

}

JSC::IsoSubspace* JSTestNamedSetterWithUnforgableProperties::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterWithUnforgableProperties.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithUnforgableProperties>)

        spaces.m_subspaceForTestNamedSetterWithUnforgableProperties = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterWithUnforgableProperties);

    else

        spaces.m_subspaceForTestNamedSetterWithUnforgableProperties = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterWithUnforgableProperties);

    auto* space = spaces.m_subspaceForTestNamedSetterWithUnforgableProperties.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterWithUnforgableProperties::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterWithUnforgableProperties::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterWithUnforgableProperties*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithUnforgableProperties.h

@@class JSTestNamedSetterWithUnforgableProperties : public JSDOMWrapper<TestNamedS

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpureForPropertyAbsence | JSC::HasStaticPropertyTable | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.cpp

#include "JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

35#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

39#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

40#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNamedSetterWithUnforgablePropertiesAndOverrid

    return IDLOperation<JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins>::call<jsTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltinsInstanceFunctionUnforgeableOperationBody>(*lexicalGlobalObject, *callFrame, "unforgeableOperation");

}

JSC::IsoSubspace* JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins>)

        spaces.m_subspaceForTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins);

    else

        spaces.m_subspaceForTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins);

    auto* space = spaces.m_subspaceForTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins.h

@@class JSTestNamedSetterWithUnforgablePropertiesAndOverrideBuiltins : public JSDO

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpure | JSC::HasStaticPropertyTable | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp

#include "JSTestNode.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructor.h"

#include "JSTestNode.h"

#include "RuntimeEnabledFeatures.h"

#include "ScriptExecutionContext.h"

40#include "WebCoreJSClientData.h"

#include <JavaScriptCore/BuiltinNames.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

44#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

4245#include <JavaScriptCore/ObjectConstructor.h>

46#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionToJSON(JSGlobalObject* l

    return IDLOperation<JSTestNode>::call<jsTestNodePrototypeFunctionToJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");

}

JSC::IsoSubspace* JSTestNode::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestNode.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestNode>)

        spaces.m_subspaceForTestNode = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestNode);

    else

        spaces.m_subspaceForTestNode = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestNode);

    auto* space = spaces.m_subspaceForTestNode.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestNode::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestNode::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestNode*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestNode.h

@@class WEBCORE_EXPORT JSTestNode : public JSNode {

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    static JSC::JSObject* serialize(JSC::JSGlobalObject&, JSTestNode& thisObject, JSDOMGlobalObject&, JSC::ThrowScope&);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestNode& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

#include "JSTestObj.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "DOMPromiseProxy.h"

#include "DOMWindow.h"

#include "DOMWrapperWorld.h"

#include <JavaScriptCore/IteratorOperations.h>

#include <JavaScriptCore/JSArray.h>

#include <JavaScriptCore/JSCInlines.h>

93#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

#include <JavaScriptCore/JSString.h>

#include <JavaScriptCore/ObjectConstructor.h>

#include <JavaScriptCore/PropertyNameArray.h>

97#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionToJSON(JSGlobalObject* le

    return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionToJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");

}

JSC::IsoSubspace* JSTestObj::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestObj.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestObj>)

        spaces.m_subspaceForTestObj = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestObj);

    else

        spaces.m_subspaceForTestObj = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestObj);

    auto* space = spaces.m_subspaceForTestObj.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestObj::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestObj::visitChildren(JSCell* cell, SlotVisitor& visitor)

{

    auto* thisObject = jsCast<JSTestObj*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestObj.h

@@class JSTestObj : public JSDOMWrapper<TestObj> {

#if ENABLE(CONDITION)

    mutable JSC::WriteBarrier<JSC::Unknown> m_cachedAttribute3;

#endif

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void visitChildren(JSCell*, JSC::SlotVisitor&);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp

#include "JSTestOverloadedConstructors.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSBlob.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructor.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

37#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

41#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestOverloadedConstructorsConstructor(JSGlobalObject* lexicalGlobalObj

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestOverloadedConstructors::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestOverloadedConstructors.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverloadedConstructors>)

        spaces.m_subspaceForTestOverloadedConstructors = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestOverloadedConstructors);

    else

        spaces.m_subspaceForTestOverloadedConstructors = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestOverloadedConstructors);

    auto* space = spaces.m_subspaceForTestOverloadedConstructors.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestOverloadedConstructors::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestOverloadedConstructors::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestOverloadedConstructors*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructors.h

@@class JSTestOverloadedConstructors : public JSDOMWrapper<TestOverloadedConstruct

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestOverloadedConstructors(JSC::Structure*, JSDOMGlobalObject&, Ref<TestOverloadedConstructors>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructorsWithSequence.cpp

#include "JSTestOverloadedConstructorsWithSequence.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructor.h"

#include "JSDOMConvertInterface.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/IteratorOperations.h>

#include <JavaScriptCore/JSArray.h>

#include <JavaScriptCore/JSCInlines.h>

40#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

41#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestOverloadedConstructorsWithSequenceConstructor(JSGlobalObject* lexi

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestOverloadedConstructorsWithSequence::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestOverloadedConstructorsWithSequence.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverloadedConstructorsWithSequence>)

        spaces.m_subspaceForTestOverloadedConstructorsWithSequence = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestOverloadedConstructorsWithSequence);

    else

        spaces.m_subspaceForTestOverloadedConstructorsWithSequence = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestOverloadedConstructorsWithSequence);

    auto* space = spaces.m_subspaceForTestOverloadedConstructorsWithSequence.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestOverloadedConstructorsWithSequence::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestOverloadedConstructorsWithSequence::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestOverloadedConstructorsWithSequence*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructorsWithSequence.h

@@class JSTestOverloadedConstructorsWithSequence : public JSDOMWrapper<TestOverloa

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestOverloadedConstructorsWithSequence(JSC::Structure*, JSDOMGlobalObject&, Ref<TestOverloadedConstructorsWithSequence>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestOverrideBuiltins.cpp

#include "JSTestOverrideBuiltins.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAbstractOperations.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMWrapperCache.h"

#include "JSNode.h"

#include "ScriptExecutionContext.h"

37#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

41#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

42#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestOverrideBuiltinsPrototypeFunctionNamedItem(JS

    return IDLOperation<JSTestOverrideBuiltins>::call<jsTestOverrideBuiltinsPrototypeFunctionNamedItemBody>(*lexicalGlobalObject, *callFrame, "namedItem");

}

JSC::IsoSubspace* JSTestOverrideBuiltins::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestOverrideBuiltins.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestOverrideBuiltins>)

        spaces.m_subspaceForTestOverrideBuiltins = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestOverrideBuiltins);

    else

        spaces.m_subspaceForTestOverrideBuiltins = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestOverrideBuiltins);

    auto* space = spaces.m_subspaceForTestOverrideBuiltins.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestOverrideBuiltins::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestOverrideBuiltins::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestOverrideBuiltins*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestOverrideBuiltins.h

@@class JSTestOverrideBuiltins : public JSDOMWrapper<TestOverrideBuiltins> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::GetOwnPropertySlotIsImpure | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | JSC::OverridesGetPropertyNames;

Source/WebCore/bindings/scripts/test/JS/JSTestPluginInterface.cpp

#include "JSTestPluginInterface.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "JSPluginElementFunctions.h"

#include "ScriptExecutionContext.h"

32#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

36#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

37#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestPluginInterfaceConstructor(JSGlobalObject* lexicalGlobalObject, En

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestPluginInterface::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestPluginInterface.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestPluginInterface>)

        spaces.m_subspaceForTestPluginInterface = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestPluginInterface);

    else

        spaces.m_subspaceForTestPluginInterface = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestPluginInterface);

    auto* space = spaces.m_subspaceForTestPluginInterface.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestPluginInterface::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestPluginInterface::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestPluginInterface*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestPluginInterface.h

@@class JSTestPluginInterface : public JSDOMWrapper<TestPluginInterface> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetCallData | JSC::OverridesGetOwnPropertySlot | JSC::ProhibitsPropertyCaching;

Source/WebCore/bindings/scripts/test/JS/JSTestPromiseRejectionEvent.cpp

#include "JSTestPromiseRejectionEvent.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "DOMPromiseProxy.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMGlobalObject.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

39#include "WebCoreJSClientData.h"

3840#include <JavaScriptCore/HeapAnalyzer.h>

3941#include <JavaScriptCore/JSCInlines.h>

42#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

43#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue jsTestPromiseRejectionEventReason(JSGlobalObject* lexicalGlobalOb

    return IDLAttribute<JSTestPromiseRejectionEvent>::get<jsTestPromiseRejectionEventReasonGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, "reason");

}

JSC::IsoSubspace* JSTestPromiseRejectionEvent::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestPromiseRejectionEvent.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestPromiseRejectionEvent>)

        spaces.m_subspaceForTestPromiseRejectionEvent = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestPromiseRejectionEvent);

    else

        spaces.m_subspaceForTestPromiseRejectionEvent = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestPromiseRejectionEvent);

    auto* space = spaces.m_subspaceForTestPromiseRejectionEvent.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestPromiseRejectionEvent::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestPromiseRejectionEvent::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestPromiseRejectionEvent*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestPromiseRejectionEvent.h

@@class JSTestPromiseRejectionEvent : public JSEvent {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestPromiseRejectionEvent& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestSerialization.cpp

#include "JSTestSerialization.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSTestSerializationIndirectInheritance.h"

#include "JSTestSerializationInheritFinal.h"

#include "ScriptExecutionContext.h"

43#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSArray.h>

#include <JavaScriptCore/JSCInlines.h>

48#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

4649#include <JavaScriptCore/ObjectConstructor.h>

50#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestSerializationPrototypeFunctionToJSON(JSGlobal

    return IDLOperation<JSTestSerialization>::call<jsTestSerializationPrototypeFunctionToJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");

}

JSC::IsoSubspace* JSTestSerialization::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestSerialization.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerialization>)

        spaces.m_subspaceForTestSerialization = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestSerialization);

    else

        spaces.m_subspaceForTestSerialization = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestSerialization);

    auto* space = spaces.m_subspaceForTestSerialization.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestSerialization::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestSerialization::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestSerialization*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestSerialization.h

@@class JSTestSerialization : public JSDOMWrapper<TestSerialization> {

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    static JSC::JSObject* serialize(JSC::JSGlobalObject&, JSTestSerialization& thisObject, JSDOMGlobalObject&, JSC::ThrowScope&);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestSerialization(JSC::Structure*, JSDOMGlobalObject&, Ref<TestSerialization>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestSerializationIndirectInheritance.cpp

#include "JSTestSerializationIndirectInheritance.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMExceptionHandling.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

31#include "WebCoreJSClientData.h"

3032#include <JavaScriptCore/HeapAnalyzer.h>

3133#include <JavaScriptCore/JSCInlines.h>

34#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

35#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@bool setJSTestSerializationIndirectInheritanceConstructor(JSGlobalObject* lexica

    return prototype->putDirect(vm, vm.propertyNames->constructor, JSValue::decode(encodedValue));

}

JSC::IsoSubspace* JSTestSerializationIndirectInheritance::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestSerializationIndirectInheritance.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerializationIndirectInheritance>)

        spaces.m_subspaceForTestSerializationIndirectInheritance = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestSerializationIndirectInheritance);

    else

        spaces.m_subspaceForTestSerializationIndirectInheritance = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestSerializationIndirectInheritance);

    auto* space = spaces.m_subspaceForTestSerializationIndirectInheritance.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestSerializationIndirectInheritance::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestSerializationIndirectInheritance::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestSerializationIndirectInheritance*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestSerializationIndirectInheritance.h

@@class JSTestSerializationIndirectInheritance : public JSTestSerializationInherit

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestSerializationIndirectInheritance& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestSerializationInherit.cpp

#include "JSTestSerializationInherit.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

3335#include <JavaScriptCore/HeapAnalyzer.h>

3436#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3538#include <JavaScriptCore/ObjectConstructor.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestSerializationInheritPrototypeFunctionToJSON(J

    return IDLOperation<JSTestSerializationInherit>::call<jsTestSerializationInheritPrototypeFunctionToJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");

}

JSC::IsoSubspace* JSTestSerializationInherit::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestSerializationInherit.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerializationInherit>)

        spaces.m_subspaceForTestSerializationInherit = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestSerializationInherit);

    else

        spaces.m_subspaceForTestSerializationInherit = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestSerializationInherit);

    auto* space = spaces.m_subspaceForTestSerializationInherit.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestSerializationInherit::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestSerializationInherit::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestSerializationInherit*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestSerializationInherit.h

@@class JSTestSerializationInherit : public JSTestSerialization {

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    static JSC::JSObject* serialize(JSC::JSGlobalObject&, JSTestSerializationInherit& thisObject, JSDOMGlobalObject&, JSC::ThrowScope&);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestSerializationInherit& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestSerializationInheritFinal.cpp

#include "JSTestSerializationInheritFinal.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

3335#include <JavaScriptCore/HeapAnalyzer.h>

3436#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

3538#include <JavaScriptCore/ObjectConstructor.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestSerializationInheritFinalPrototypeFunctionToJ

    return IDLOperation<JSTestSerializationInheritFinal>::call<jsTestSerializationInheritFinalPrototypeFunctionToJSONBody>(*lexicalGlobalObject, *callFrame, "toJSON");

}

JSC::IsoSubspace* JSTestSerializationInheritFinal::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestSerializationInheritFinal.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerializationInheritFinal>)

        spaces.m_subspaceForTestSerializationInheritFinal = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestSerializationInheritFinal);

    else

        spaces.m_subspaceForTestSerializationInheritFinal = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestSerializationInheritFinal);

    auto* space = spaces.m_subspaceForTestSerializationInheritFinal.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestSerializationInheritFinal::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestSerializationInheritFinal::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestSerializationInheritFinal*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestSerializationInheritFinal.h

@@class JSTestSerializationInheritFinal : public JSTestSerializationInherit {

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    static JSC::JSObject* serialize(JSC::JSGlobalObject&, JSTestSerializationInheritFinal& thisObject, JSDOMGlobalObject&, JSC::ThrowScope&);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

    TestSerializationInheritFinal& wrapped() const

    {

Source/WebCore/bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp

#include "JSTestSerializedScriptValueInterface.h"

#include "ActiveDOMObject.h"

28#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSMessagePort.h"

#include "ScriptExecutionContext.h"

#include "SerializedScriptValue.h"

42#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSArray.h>

#include <JavaScriptCore/JSCInlines.h>

47#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

48#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestSerializedScriptValueInterfacePrototypeFuncti

    return IDLOperation<JSTestSerializedScriptValueInterface>::call<jsTestSerializedScriptValueInterfacePrototypeFunctionFunctionReturningBody>(*lexicalGlobalObject, *callFrame, "functionReturning");

}

JSC::IsoSubspace* JSTestSerializedScriptValueInterface::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestSerializedScriptValueInterface.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestSerializedScriptValueInterface>)

        spaces.m_subspaceForTestSerializedScriptValueInterface = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestSerializedScriptValueInterface);

    else

        spaces.m_subspaceForTestSerializedScriptValueInterface = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestSerializedScriptValueInterface);

    auto* space = spaces.m_subspaceForTestSerializedScriptValueInterface.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestSerializedScriptValueInterface::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestSerializedScriptValueInterface::visitChildren(JSCell* cell, SlotVisitor& visitor)

{

    auto* thisObject = jsCast<JSTestSerializedScriptValueInterface*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.h

@@class JSTestSerializedScriptValueInterface : public JSDOMWrapper<TestSerializedS

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    mutable JSC::WriteBarrier<JSC::Unknown> m_cachedValue;

    mutable JSC::WriteBarrier<JSC::Unknown> m_cachedReadonlyValue;

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void visitChildren(JSCell*, JSC::SlotVisitor&);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifier.cpp

#include "JSTestStringifier.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierPrototypeFunctionToString(JSGlobal

    return IDLOperation<JSTestStringifier>::call<jsTestStringifierPrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifier::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifier.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifier>)

        spaces.m_subspaceForTestStringifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifier);

    else

        spaces.m_subspaceForTestStringifier = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifier);

    auto* space = spaces.m_subspaceForTestStringifier.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifier::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifier::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifier*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifier.h

@@class JSTestStringifier : public JSDOMWrapper<TestStringifier> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifier(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifier>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierAnonymousOperation.cpp

#include "JSTestStringifierAnonymousOperation.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierAnonymousOperationPrototypeFunctio

    return IDLOperation<JSTestStringifierAnonymousOperation>::call<jsTestStringifierAnonymousOperationPrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifierAnonymousOperation::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifierAnonymousOperation.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierAnonymousOperation>)

        spaces.m_subspaceForTestStringifierAnonymousOperation = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifierAnonymousOperation);

    else

        spaces.m_subspaceForTestStringifierAnonymousOperation = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifierAnonymousOperation);

    auto* space = spaces.m_subspaceForTestStringifierAnonymousOperation.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifierAnonymousOperation::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifierAnonymousOperation::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifierAnonymousOperation*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierAnonymousOperation.h

@@class JSTestStringifierAnonymousOperation : public JSDOMWrapper<TestStringifierA

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifierAnonymousOperation(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifierAnonymousOperation>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierNamedOperation.cpp

#include "JSTestStringifierNamedOperation.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierNamedOperationPrototypeFunctionToS

    return IDLOperation<JSTestStringifierNamedOperation>::call<jsTestStringifierNamedOperationPrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifierNamedOperation::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifierNamedOperation.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierNamedOperation>)

        spaces.m_subspaceForTestStringifierNamedOperation = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifierNamedOperation);

    else

        spaces.m_subspaceForTestStringifierNamedOperation = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifierNamedOperation);

    auto* space = spaces.m_subspaceForTestStringifierNamedOperation.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifierNamedOperation::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifierNamedOperation::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifierNamedOperation*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierNamedOperation.h

@@class JSTestStringifierNamedOperation : public JSDOMWrapper<TestStringifierNamed

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifierNamedOperation(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifierNamedOperation>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierOperationImplementedAs.cpp

#include "JSTestStringifierOperationImplementedAs.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierOperationImplementedAsPrototypeFun

    return IDLOperation<JSTestStringifierOperationImplementedAs>::call<jsTestStringifierOperationImplementedAsPrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifierOperationImplementedAs::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifierOperationImplementedAs.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierOperationImplementedAs>)

        spaces.m_subspaceForTestStringifierOperationImplementedAs = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifierOperationImplementedAs);

    else

        spaces.m_subspaceForTestStringifierOperationImplementedAs = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifierOperationImplementedAs);

    auto* space = spaces.m_subspaceForTestStringifierOperationImplementedAs.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifierOperationImplementedAs::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifierOperationImplementedAs::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifierOperationImplementedAs*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierOperationImplementedAs.h

@@class JSTestStringifierOperationImplementedAs : public JSDOMWrapper<TestStringif

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifierOperationImplementedAs(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifierOperationImplementedAs>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierOperationNamedToString.cpp

#include "JSTestStringifierOperationNamedToString.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMConvertStrings.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

33#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

37#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

38#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierOperationNamedToStringPrototypeFun

    return IDLOperation<JSTestStringifierOperationNamedToString>::call<jsTestStringifierOperationNamedToStringPrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifierOperationNamedToString::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifierOperationNamedToString.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierOperationNamedToString>)

        spaces.m_subspaceForTestStringifierOperationNamedToString = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifierOperationNamedToString);

    else

        spaces.m_subspaceForTestStringifierOperationNamedToString = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifierOperationNamedToString);

    auto* space = spaces.m_subspaceForTestStringifierOperationNamedToString.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifierOperationNamedToString::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifierOperationNamedToString::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifierOperationNamedToString*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierOperationNamedToString.h

@@class JSTestStringifierOperationNamedToString : public JSDOMWrapper<TestStringif

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifierOperationNamedToString(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifierOperationNamedToString>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierReadOnlyAttribute.cpp

#include "JSTestStringifierReadOnlyAttribute.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierReadOnlyAttributePrototypeFunction

    return IDLOperation<JSTestStringifierReadOnlyAttribute>::call<jsTestStringifierReadOnlyAttributePrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifierReadOnlyAttribute::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifierReadOnlyAttribute.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierReadOnlyAttribute>)

        spaces.m_subspaceForTestStringifierReadOnlyAttribute = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifierReadOnlyAttribute);

    else

        spaces.m_subspaceForTestStringifierReadOnlyAttribute = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifierReadOnlyAttribute);

    auto* space = spaces.m_subspaceForTestStringifierReadOnlyAttribute.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifierReadOnlyAttribute::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifierReadOnlyAttribute::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifierReadOnlyAttribute*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierReadOnlyAttribute.h

@@class JSTestStringifierReadOnlyAttribute : public JSDOMWrapper<TestStringifierRe

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifierReadOnlyAttribute(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifierReadOnlyAttribute>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierReadWriteAttribute.cpp

#include "JSTestStringifierReadWriteAttribute.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructorNotConstructable.h"

#include "JSDOMOperation.h"

#include "JSDOMWrapperCache.h"

#include "ScriptExecutionContext.h"

34#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSCInlines.h>

38#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

39#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestStringifierReadWriteAttributePrototypeFunctio

    return IDLOperation<JSTestStringifierReadWriteAttribute>::call<jsTestStringifierReadWriteAttributePrototypeFunctionToStringBody>(*lexicalGlobalObject, *callFrame, "toString");

}

JSC::IsoSubspace* JSTestStringifierReadWriteAttribute::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestStringifierReadWriteAttribute.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestStringifierReadWriteAttribute>)

        spaces.m_subspaceForTestStringifierReadWriteAttribute = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestStringifierReadWriteAttribute);

    else

        spaces.m_subspaceForTestStringifierReadWriteAttribute = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestStringifierReadWriteAttribute);

    auto* space = spaces.m_subspaceForTestStringifierReadWriteAttribute.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestStringifierReadWriteAttribute::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestStringifierReadWriteAttribute::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestStringifierReadWriteAttribute*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestStringifierReadWriteAttribute.h

@@class JSTestStringifierReadWriteAttribute : public JSDOMWrapper<TestStringifierR

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

protected:

    JSTestStringifierReadWriteAttribute(JSC::Structure*, JSDOMGlobalObject&, Ref<TestStringifierReadWriteAttribute>&&);

Source/WebCore/bindings/scripts/test/JS/JSTestTypedefs.cpp

#include "JSTestTypedefs.h"

#include "ActiveDOMObject.h"

25#include "DOMIsoSubspaces.h"

#include "JSDOMAttribute.h"

#include "JSDOMBinding.h"

#include "JSDOMConstructor.h"

#include "JSTestSubObj.h"

#include "ScriptExecutionContext.h"

#include "SerializedScriptValue.h"

50#include "WebCoreJSClientData.h"

#include <JavaScriptCore/FunctionPrototype.h>

#include <JavaScriptCore/HeapAnalyzer.h>

#include <JavaScriptCore/JSArray.h>

#include <JavaScriptCore/JSCInlines.h>

55#include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>

56#include <JavaScriptCore/SubspaceInlines.h>

#include <wtf/GetPtr.h>

#include <wtf/PointerPreparations.h>

#include <wtf/URL.h>

@@EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithException(

    return IDLOperation<JSTestTypedefs>::call<jsTestTypedefsPrototypeFunctionMethodWithExceptionBody>(*lexicalGlobalObject, *callFrame, "methodWithException");

}

JSC::IsoSubspace* JSTestTypedefs::subspaceForImpl(JSC::VM& vm)

{

    auto& clientData = *static_cast<JSVMClientData*>(vm.clientData);

    auto& spaces = clientData.subspaces();

    if (auto* space = spaces.m_subspaceForTestTypedefs.get())

        return space;

    if constexpr (std::is_base_of_v<JSC::JSDestructibleObject, JSTestTypedefs>)

        spaces.m_subspaceForTestTypedefs = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.destructibleObjectHeapCellType.get(), JSTestTypedefs);

    else

        spaces.m_subspaceForTestTypedefs = makeUnique<IsoSubspace> ISO_SUBSPACE_INIT(vm.heap, vm.cellHeapCellType.get(), JSTestTypedefs);

    auto* space = spaces.m_subspaceForTestTypedefs.get();

IGNORE_WARNINGS_BEGIN("unreachable-code")

IGNORE_WARNINGS_BEGIN("tautological-compare")

    if (&JSTestTypedefs::visitOutputConstraints != &JSC::JSCell::visitOutputConstraints)

        clientData.outputConstraintSpaces().append(space);

IGNORE_WARNINGS_END

IGNORE_WARNINGS_END

    return space;

}

void JSTestTypedefs::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)

{

    auto* thisObject = jsCast<JSTestTypedefs*>(cell);

Source/WebCore/bindings/scripts/test/JS/JSTestTypedefs.h

@@class JSTestTypedefs : public JSDOMWrapper<TestTypedefs> {

    }

    static JSC::JSValue getConstructor(JSC::VM&, const JSC::JSGlobalObject*);

    template<typename, JSC::SubspaceAccess mode> static JSC::IsoSubspace* subspaceFor(JSC::VM& vm)

    {

        if constexpr (mode == JSC::SubspaceAccess::Concurrently)

            return nullptr;

        return subspaceForImpl(vm);

    }

    static JSC::IsoSubspace* subspaceForImpl(JSC::VM& vm);

    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);

public:

    static constexpr unsigned StructureFlags = Base::StructureFlags | JSC::HasStaticPropertyTable;