applyPlugins.append("            pluginsBlockScript.setScriptSource(scriptSource(pluginsBlockClass));\n");
        applyPlugins.append("            pluginsBlockScript.init(target, target.getServices());\n");
        applyPlugins.append("            pluginsBlockScript.run();\n");
        for (PluginRequest pluginRequest : pluginRequests) {

    def setup() {
        executer.requireOwnGradleUserHomeDir()
    }

    static String applyJavaPlugin() {
        applyPlugins(['java'])
    }

    static String applyGroovyPlugin() {
        applyPlugins(['groovy'])
    }

    static String applyPlugins(List<String> plugins) {
        """
            plugins {
                ${plugins.collect { "id '$it'\n"}.join('')}
            }
        """

        }

    private
    fun static(applyPlugins: ResidualProgram.Instruction): Static =
        when (programTarget) {
            ProgramTarget.Project -> Static(
                SetupEmbeddedKotlin,
                applyPlugins,
                ApplyBasePlugins
            )

            else -> Static(
                SetupEmbeddedKotlin,
                applyPlugins
            )
        }

        subject.handle(initialRequests, scriptHandler, target, targetScope)

        // then:
        verify(pluginRequestApplicator).applyPlugins(initialRequests.mergeWith(autoAppliedPlugins), scriptHandler, pluginManager, targetScope)
    }

     * the requested plugins.
     *
     * A null target indicates that no plugin requests should be resolved but only the setup of the given
     * {@link ClassLoaderScope}.
     */
    void applyPlugins(PluginRequests requests, ScriptHandlerInternal scriptHandler, @Nullable PluginManagerInternal target, ClassLoaderScope classLoaderScope);

    @EventScope(Scope.Build.class)
    @StatefulListener

            val pluginManager = get(PluginManagerInternal::class.java)
            val pluginApplicator = get(PluginRequestApplicator::class.java)
            pluginApplicator.applyPlugins(PluginRequests.of(pluginRequests), scriptHandler, pluginManager, targetScope)
        }
        targetScope.lock()
    }
}


private

    ) {
        val initialRequests = pluginRequests ?: PluginRequests.EMPTY
        val autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialRequests, target)
        pluginRequestApplicator.applyPlugins(
            initialRequests.mergeWith(autoAppliedPlugins),
            scriptHandler,
            target.pluginManager,
            targetScope
        )
    }

private
data class ScriptPluginPlugins(
    val scriptPlugin: PrecompiledScriptPlugin,
    val appliedPlugins: List<String>
)


private
fun ProjectInternal.applyPlugins(pluginRequests: PluginRequests) {
    serviceOf<PluginRequestApplicator>().applyPlugins(
        pluginRequests,
        buildscript,
        pluginManager,
        classLoaderScope
    )
}


private

        this.pluginVersionTracker = pluginVersionTracker;
        this.pluginApplicationListenerBroadcaster = listenerManager.getBroadcaster(PluginApplicationListener.class);
    }

    @Override
    public void applyPlugins(PluginRequests requests, final ScriptHandlerInternal scriptHandler, @Nullable final PluginManagerInternal target, final ClassLoaderScope classLoaderScope) {
        if (target == null || requests.isEmpty()) {

            PluginRequests allPlugins = initialPluginRequests.mergeWith(autoAppliedPlugins);
            pluginRequestApplicator.applyPlugins(allPlugins, scriptHandler, pluginManager, targetScope);
            // Pass 2, compile everything except buildscript {}, pluginManagement{}, and plugin requests, then run