import org.gradle.api.internal.DomainObjectContext;
import org.gradle.groovy.scripts.ScriptSource;

public interface ScriptHandlerFactory {
    ScriptHandlerInternal create(ScriptSource scriptSource, ClassLoaderScope classLoaderScope);

    ScriptHandlerInternal create(ScriptSource scriptSource, ClassLoaderScope classLoaderScope, DomainObjectContext context);

import org.gradle.configuration.ScriptPlugin
import org.gradle.groovy.scripts.ScriptSource


internal
class DeclarativeDslPlugin(
    private val scriptSource: ScriptSource,
    private val script: (Any) -> Unit
) : ScriptPlugin {

    override fun getSource() =
        scriptSource

    override fun apply(target: Any) {
        script(target)
    }

 */
public class PluginRequestCollector {
    public static final String EMPTY_VALUE = "cannot be null or empty";

    private final ScriptSource scriptSource;

    public PluginRequestCollector(ScriptSource scriptSource) {
        this.scriptSource = scriptSource;
    }

    private final List<PluginDependencySpecImpl> specs = new LinkedList<PluginDependencySpecImpl>();

    private final TextResource resource;

    public static ScriptSource of(ScriptSource source) {
        if (source.getResource().isContentCached()) {
            return source;
        }
        return new CachingScriptSource(source);
    }

    private CachingScriptSource(ScriptSource source) {
        super(source);
        resource = new CachingTextResource(source.getResource());
    }

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.groovy.scripts.internal.BuildScriptData;
import org.gradle.groovy.scripts.internal.CompileOperation;

public interface CompileOperationFactory {
    CompileOperation<?> getPluginsBlockCompileOperation(ScriptTarget initialPassScriptTarget);

    CompileOperation<BuildScriptData> getScriptCompileOperation(ScriptSource scriptSource, ScriptTarget scriptTarget);

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

@EventScope(Scope.Build.class)
public interface ScriptSourceListener {

    /**
     * Called when remote script was applied.
     */
    void scriptSourceObserved(ScriptSource scriptSource);

import org.gradle.configuration.ScriptPlugin
import org.gradle.groovy.scripts.ScriptSource
import org.gradle.kotlin.dsl.support.loggerFor


internal
class KotlinScriptPlugin(
    private val scriptSource: ScriptSource,
    private val script: (Any) -> Unit
) : ScriptPlugin {

    override fun getSource() =
        scriptSource

    override fun apply(target: Any) {

class KotlinScriptHost<out T : Any> internal constructor(
    val target: T,
    val scriptSource: ScriptSource,
    internal val scriptHandler: ScriptHandler,
    internal val targetScope: ClassLoaderScope,
    private val baseScope: ClassLoaderScope,
    private val serviceRegistry: ServiceRegistry
) {

    internal
    val fileName = scriptSource.fileName!!

    internal
    val fileOperations: FileOperations by unsafeLazy {

    private final ScriptSource scriptSource = Mock(ScriptSource)
    private final TaskExecuter delegate = Mock(TaskExecuter)
    private final SkipOnlyIfTaskExecuter executer = new SkipOnlyIfTaskExecuter(delegate)

    def setup() {
        ProjectInternal project = Mock(ProjectInternal)

        task.getProject() >> project
        project.getBuildScriptSource() >> scriptSource
        task.getOnlyIf() >> spec
    }

) : ScriptPluginFactory {

    override fun create(
        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean
    ): ScriptPlugin =

        KotlinScriptPlugin(scriptSource) { target ->

            kotlinScriptEvaluator
                .evaluate(