public ExecutionResult<Void> execute(GradleInternal gradle, FinalizedExecutionPlan plan) {
        return buildOperationRunner.call(new ExecuteTasks(gradle, plan));
    }

    private class ExecuteTasks implements CallableBuildOperation<ExecutionResult<Void>> {
        private final GradleInternal gradle;
        private final FinalizedExecutionPlan plan;

        public ExecuteTasks(GradleInternal gradle, FinalizedExecutionPlan plan) {

    PluginRegistry createPluginRegistry(PluginRegistry parentRegistry) {
        return parentRegistry.createChild(get(GradleInternal.class).getClassLoaderScope());
    }

    @Provides

        @Override
        public void projectsLoaded(Gradle gradle) {
            GradleInternal gradleInternal = (GradleInternal) gradle;
            // Run only those tasks scheduled by this selector and not the default tasks
            gradleInternal.getStartParameter().setTaskRequests(Collections.emptyList());
            ProjectInternal rootProject = gradleInternal.getRootProject();
            rootProjectState = rootProject.getOwner();

    }

    public void notify(GradleInternal gradle) {
        buildOperationRunner.run(new NotifyProjectsEvaluatedListeners(gradle));
    }

    private static class NotifyProjectsEvaluatedListeners implements RunnableBuildOperation {
        private final GradleInternal gradle;

        public NotifyProjectsEvaluatedListeners(GradleInternal gradle) {
            this.gradle = gradle;
        }

        softwareTypeRegistry: SoftwareTypeRegistry,
        gradleInternal: GradleInternal,
        buildLayoutFactory: BuildLayoutFactory
    ): DeclarativeKotlinScriptEvaluator {
        val schemaBuilder = StoringInterpretationSchemaBuilder(GradleProcessInterpretationSchemaBuilder(softwareTypeRegistry), buildLayoutFactory.settingsDir(gradleInternal))
        return defaultDeclarativeScriptEvaluator(schemaBuilder, softwareTypeRegistry)

        def project = project('root', null, Stub(GradleInternal))

        when:
        project.ant({ AntBuilder ant -> ant.importBuild('someAntBuild') } as Action<AntBuilder>)

        then:
        1 * project.ant.importBuild('someAntBuild')
    }

    def "can configure artifacts with an Action"() {
        given:
        def project = project('root', null, Stub(GradleInternal))

        when:

import org.gradle.api.internal.GradleInternal
import org.gradle.api.problems.Problems
import org.gradle.api.problems.Severity

def gradleInternal = gradle as GradleInternal
def problems = gradleInternal.services.get(Problems)

problems.forNamespace('buildscript').reporting {
    it.id('adhoc-script-deprecation', 'Deprecated script plugin')
        .contextualLabel("Deprecated script plugin 'demo-script-plugin'")
        .severity(Severity.WARNING)

 */
package org.gradle.internal.cc.impl

import org.gradle.api.internal.GradleInternal
import org.gradle.api.internal.SettingsInternal
import org.gradle.execution.EntryTaskSelector
import org.gradle.execution.plan.ExecutionPlan
import org.gradle.internal.build.BuildModelController


class ConfigurationCacheAwareBuildModelController(
    private val model: GradleInternal,
    private val delegate: BuildModelController,

 */
package org.gradle.kotlin.dsl.support

import org.gradle.api.internal.GradleInternal
import org.gradle.api.invocation.Gradle


inline fun <reified T : Any> Gradle.serviceOf(): T =
    (gradle as GradleInternal).services.get()


internal
fun serviceRegistryOf(gradle: Gradle) =

    }

    @Override
    public void prepareProjects(GradleInternal gradle) {
        buildOperationRunner.run(new ConfigureBuild(gradle));
    }

    private class ConfigureBuild implements RunnableBuildOperation {
        private final GradleInternal gradle;

        public ConfigureBuild(GradleInternal gradle) {
            this.gradle = gradle;
        }

        @Override