cid: String,
        scriptFile: File?,
        environment: Environment,
        report: Report,
        previousDependencies: KotlinScriptExternalDependencies?,
        classPathBlocksHash: ByteArray? = null
    ): KotlinScriptExternalDependencies? {

        val request = scriptModelRequestFrom(scriptFile, environment, cid)
        log(SubmittedModelRequest(cid, scriptFile, request))

    }


private
fun hasProjectDependentClassPath(scriptFile: File): Boolean =
    when (kotlinScriptTypeFor(scriptFile)) {
        KotlinScriptType.INIT -> false
        else -> true
    }


internal
fun projectRootOf(scriptFile: File, importedProjectRoot: File, stopAt: File? = null): File {

                    +"gradle-bar"
                }
            }
        }

        assertThat(
            sourcePathFor(
                classPath = ClassPath.EMPTY,
                scriptFile = null,
                projectDir = folder("project"),
                gradleHomeDir = folder("gradle"),
                sourceDistributionResolver = mock()
            ).asFiles,
            hasItems(

        private final File scriptFile;
        private final String className;

        public PrecompiledScriptPluginSource(File scriptFile, String className, TextFileResourceLoader resourceLoader) {
            super(new TextResourceScriptSource(resourceLoader.loadFile("script", scriptFile)));
            this.scriptFile = scriptFile;
            this.className = "precompiled_" + className;
        }

    String scriptUrl
    TestFile scriptFile
    String scriptName = "remote-script.gradle"
    def configurationCache

    def setup() {
        server.start()

        scriptUrl = "${server.uri}/${scriptName}"
        scriptFile = file("remote-script.gradle") << """
            println 'loaded remote script'
        """
        server.expectGet "/$scriptName", scriptFile

        buildFile << """

        def scriptName = "script-cached.gradle"
        def scriptFile = file("script.gradle")
        scriptFile.setText("""println 'loaded external script 1'""", "UTF-8")
        scriptFile.makeOlder()

        and:
        buildFile << "apply from: '${server.uri}/${scriptName}'"

        when:
        server.expectGet('/' + scriptName, scriptFile)

        then:
        succeeds 'help'

internal
fun buildEditorReportsFor(
    scriptFile: File?,
    exceptions: List<Exception>,
    locationAwareHints: Boolean
): List<EditorReport> =
    if (scriptFile == null || exceptions.isEmpty()) emptyList()
    else inferEditorReportsFrom(scriptFile.canonicalFile, exceptions.asSequence(), locationAwareHints)


private
fun inferEditorReportsFrom(
    scriptFile: File,
    exceptions: Sequence<Exception>,

                    "scriptFile" to scriptFile,
                    "request" to prettyPrintAny(request, indentation = 2)
                )
            )

        is ReceivedModelResponse ->
            prettyPrint(
                "ReceivedModelResponse",
                sequenceOf(
                    "correlationId" to correlationId,
                    "scriptFile" to scriptFile,

import org.jetbrains.kotlin.name.NameUtils

import java.io.File
import java.util.Locale


internal
data class PrecompiledScriptPlugin(internal val scriptFile: File) {

    val scriptFileName: String
        get() = scriptFile.name

    /**
     * Gradle plugin id inferred from the script file name and package declaration (if any).
     */
    val id by lazy {

        this.installDir = installDir
        this.os = os
    }

    ExecOutput exec(Object... args) {
        assertInstalled()
        return scriptFile().exec(args)
    }

    private TestFile scriptFile() {
        if (os.windows) {
            return installDir.listFiles().find { it.file && it.name.endsWith(".bat") }
        } else {
            return installDir.listFiles().find { it.file }