private DefaultExtensionsSchema(Iterable<ExtensionSchema> extensionSchemas) {
        this.extensionSchemas = extensionSchemas;
    }

    @Override
    public Iterator<ExtensionSchema> iterator() {
        return extensionSchemas.iterator();
    }

    @Override
    public Iterable<ExtensionSchema> getElements() {
        return this;
    }

 * @since 4.5
 */
public interface ExtensionsSchema extends NamedDomainObjectCollectionSchema, Iterable<ExtensionsSchema.ExtensionSchema> {

    /**
     * {@inheritDoc}
     */
    @Override
    Iterable<ExtensionSchema> getElements();

    /**
     * Schema of an extension.
     *
     * @since 4.5
     */
    interface ExtensionSchema extends NamedDomainObjectCollectionSchema.NamedDomainObjectSchema {

    internal
    open class KotlinJvmOptionsBase : KotlinJvmOptions

    interface KotlinJvmOptions

    private
    fun <T> extensionSchema(name: String, publicType: TypeOf<T>): ExtensionsSchema.ExtensionSchema = mock {
        on { getName() } doReturn name
        on { getPublicType() } doReturn publicType
    }

            val extensionsMock = run {
                val myExtensionMock = mock<MyExtension>()
                val extensionsSchemaMock = mock<ExtensionsSchema> {
                    on { elements }.thenReturn(listOf<ExtensionSchema>(object : ExtensionSchema {
                        override fun getName(): String = "myExtension"
                        override fun getPublicType(): TypeOf<*> = TypeOf.typeOf(MyExtension::class.java)

import java.io.BufferedWriter
import java.io.File
import kotlin.reflect.KClass


internal
class GenerateVersionCatalogAccessors(
    private val versionCatalogExtensionSchemas: List<ExtensionsSchema.ExtensionSchema>,
    rootProject: Project,
    buildSrcClassLoaderScope: ClassLoaderScope,
    classLoaderHash: HashCode,
    fileCollectionFactory: FileCollectionFactory,
    inputFingerprinter: InputFingerprinter,

    }

    private static class ExtensionHolder<T> implements ExtensionsSchema.ExtensionSchema {
        private final String name;
        private final TypeOf<T> publicType;
        protected final T extension;

        private ExtensionHolder(String name, TypeOf<T> publicType, T extension) {

 * The `@DeferredConfigurable` annotation has been removed.
 * The method `isDeferredConfigurable()` was removed from `ExtensionSchema`.
 * `IdeaPlugin.performPostEvaluationActions()` and `EclipsePlugin.performPostEvaluationActions()` have been removed.
 * `The `BroadcastingCollectionEventRegister.getAddAction()` method has been removed with no replacement.

    def 'source set extension exposes its public type'() {
        when:
        project.pluginManager.apply(AntlrPlugin)

        then:
        def main = project.sourceSets.main
        main.extensions.extensionsSchema.find { it.name == 'antlr' }.publicType == typeOf(AntlrSourceDirectorySet)
    }

import groovy.lang.Closure;
import org.gradle.api.Action;
import org.gradle.api.internal.plugins.DslObject;
import org.gradle.api.internal.plugins.ExtensionContainerInternal;
import org.gradle.api.plugins.ExtensionsSchema;
import org.gradle.api.plugins.ExtraPropertiesExtension;
import org.gradle.api.reflect.TypeOf;
import org.gradle.internal.Cast;
import org.gradle.internal.Describables;

        sourceSet.extensions.extensionsSchema.elements.size() == 1

        when:
        sourceSet.extensions.extraProperties.set("foo", "bar")
        sourceSet.extensions.add("bazar", "cathedral")

        then:
        sourceSet.extensions.extraProperties.get("foo") == "bar"
        sourceSet.extensions.extensionsSchema.elements.size() == 2