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


private

        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean
    ): ScriptPlugin =
        DeclarativeDslPlugin(scriptSource) { target ->
            when (val result = declarativeKotlinScriptEvaluator.evaluate(target, scriptSource, targetScope)) {
                is EvaluationResult.Evaluated -> Unit

    override fun evaluate(
        target: Any,
        scriptSource: ScriptSource,
        targetScope: ClassLoaderScope
    ): EvaluationResult<ConversionStepResult> {
        val scriptContext = scriptContextFor(target, scriptSource, targetScope)
        return when (val built = schemaBuilder.getEvaluationSchemaForScript(scriptContext)) {

import java.io.File
import java.util.Optional


interface KotlinScriptEvaluator {

    fun evaluate(
        target: Any,
        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean,
        options: EvalOptions
    )
}


internal
class StandardKotlinScriptEvaluator(

                InterpretationSequenceAvailable(
                    settingsInterpretationSequence(scriptContext.settings, scriptContext.targetScope, scriptContext.scriptSource, softwareTypeRegistry)
                )
            }

            is DeclarativeScriptContext.ProjectScript -> InterpretationSequenceAvailable(projectInterpretationSequence)
        }

            this.isEmpty = isEmpty;
            this.hasMethods = hasMethods;
            this.scriptBaseClass = scriptBaseClass;
            this.scriptClassPath = scriptClassPath;
            this.targetScope = targetScope;
            this.source = source;

import org.gradle.internal.declarativedsl.project.thirdPartyExtensions
import org.gradle.plugin.software.internal.SoftwareTypeRegistry


internal
fun settingsInterpretationSequence(
    settings: SettingsInternal,
    targetScope: ClassLoaderScope,
    scriptSource: ScriptSource,
    softwareTypeRegistry: SoftwareTypeRegistry
): InterpretationSequence =
    DefaultInterpretationSequence(
        listOf(

        ScriptSource scriptSource, ScriptHandler scriptHandler, ClassLoaderScope targetScope,
        ClassLoaderScope baseScope, boolean topLevelScript
    ) {
        scriptSourceListener.scriptSourceObserved(scriptSource);
        ScriptPlugin scriptPlugin = scriptPluginFactoryFor(scriptSource.getFileName())
            .create(scriptSource, scriptHandler, targetScope, baseScope, topLevelScript);

internal
class TypesafeProjectAccessorsComponent(targetScope: ClassLoaderScope) : ObjectConversionComponent, AnalysisSchemaComponent {
    private
    val projectAccessorsClass: KClass<*>? = try {
        targetScope.localClassLoader.loadClass("org.gradle.accessors.dm.RootProjectAccessor").kotlin
    } catch (e: ClassNotFoundException) {
        null
    }

    }

    @Override
    public <T extends Script, M> CompiledScript<T, M> compile(
        final ScriptSource source, final Class<T> scriptBaseClass, final Object target,
        final ClassLoaderScope targetScope,
        final CompileOperation<M> operation,
        final Action<? super ClassNode> verifier
    ) {
        assert source.getResource().isContentCached();
        if (source.getResource().getHasEmptyContent()) {