import org.gradle.kotlin.dsl.resolver.EditorReports
import org.gradle.kotlin.dsl.resolver.SourceDistributionResolver
import org.gradle.kotlin.dsl.resolver.SourcePathProvider
import org.gradle.kotlin.dsl.support.ImplicitImports
import org.gradle.kotlin.dsl.support.KotlinScriptType
import org.gradle.kotlin.dsl.support.kotlinScriptTypeFor
import org.gradle.kotlin.dsl.support.serviceOf
import org.gradle.kotlin.dsl.tooling.models.EditorReport

    prettyPrint(
        "KotlinBuildScriptModel",
        sequenceOf(
            "classPath" to compactStringFor(classPath),
            "sourcePath" to compactStringFor(sourcePath),
            "implicitImports" to compactStringFor(implicitImports, '.'),
            "editorReports" to editorReports.toString(),
            "exceptions" to stringForExceptions(exceptions, indentation)
        ),
        indentation
    )
}

            action()

        override fun onScriptClassLoaded(scriptSource: ScriptSource, specializedProgram: Class<*>) = Unit

        override val implicitImports: List<String>
            get() = ImplicitImports(DefaultImportsReader()).list

        override val compilerOptions: KotlinCompilerOptions
            get() = KotlinCompilerOptions()
    }
}

    data class StandardKotlinBuildScriptModel(
        private val classPath: List<File> = emptyList(),
        private val sourcePath: List<File> = emptyList(),
        private val implicitImports: List<String> = emptyList(),
        private val editorReports: List<EditorReport> = emptyList(),
        private val exceptions: List<String> = emptyList(),
        private val enclosingScriptProjectDir: File? = null

                    originalSourceHash = programId.sourceHash,
                    programKind = programKind,
                    programTarget = programTarget,
                    implicitImports = host.implicitImports,
                    logger = interpreterLogger,
                    temporaryFileProvider = temporaryFileProvider,
                    compileBuildOperationRunner = host::runCompileBuildOperation,

import org.gradle.internal.service.ServiceRegistrationProvider


internal
object GlobalServices : ServiceRegistrationProvider {

    @Provides
    fun createImplicitImports(importsReader: ImportsReader) =
        ImplicitImports(importsReader)

        assert actual instanceof KotlinDslScriptModel

        checkModel(actual, expected, [
            { it.classPath },
            { it.sourcePath },
            { it.implicitImports },
            // TODO:isolated support editor reports
//            [{ it.editorReports }, { a, e -> checkEditorReport(a, e) }],
            { it.exceptions },
        ])
    }

            compileKotlinScriptTo(
                outputDir,
                "bar()",
                scriptDefinitionFromTemplate(
                    template = TheKotlinScriptTemplate::class,
                    implicitImports = emptyList(),
                    implicitReceiver = TheImplicitReceiver::class
                )
            )

            withClassLoaderFor(outputDir) {

fun configureKotlinCompilerArguments(
    objects: ObjectFactory,
    implicitImports: ImplicitImports,
    classpathFingerprinter: ClasspathFingerprinter,
    compileClasspath: FileCollection,
    accessorsMetadata: Provider<Directory>
) {
    configureKotlinCompilerArguments(
        objects,
        resolverEnvironmentStringFor(
            implicitImports,
            classpathFingerprinter,
            compileClasspath,

            plugins { java }
        """)

        expect:
        assertThat(
            kotlinBuildScriptModelFor(projectDir, pluginFile).implicitImports,
            hasItems(
                startsWith("gradle.kotlin.dsl.accessors._"),
                startsWith("gradle.kotlin.dsl.plugins._")
            )
        )
    }