stage1 = CachedScript.CompilationStage(Gradle, ScriptPlugin, "stage1", Descriptions.script, file),
        stage2 = CachedScript.CompilationStage(Gradle, ScriptPlugin, "stage2", Descriptions.script, file, hasInitscriptBlock && hasBody)
    )


fun cachedSettingsFile(file: File, hasBuildscriptBlock: Boolean = false, hasBody: Boolean = false) =
    CachedScript.WholeFile(

    /**
     * A script that must be dynamically evaluated after stage 1 completes and the script classpath
     * becomes available.
     */
    data class Script(val source: ProgramSource) : Program()

    /**
     * A [Stage1] program followed by a stage 2 [Script] program.
     */
    data class Staged(val stage1: Stage1, val stage2: Script) : Program()

    /**

        else -> CloseTargetScope
    }

    private
    fun reduceStagedProgram(program: Program.Staged): Dynamic =

        Dynamic(
            reduceStage1Program(program.stage1),
            program.stage2.source
        )

    private
    fun reduceStage1Program(stage1: Program.Stage1): Static = when (stage1) {

        is Program.Buildscript ->

            when (programTarget) {

}


sealed class CachedScript {

    class WholeFile(
        val stage1: CompilationStage,
        val stage2: CompilationStage
    ) : CachedScript() {

        val stages = listOf(stage1, stage2)
    }

    class CompilationStage(
        programTarget: ProgramTarget,
        programKind: ProgramKind,
        val stage: String,
        sourceDescription: String,
        val file: File,

                    Static(
                        SetupEmbeddedKotlin,
                        ApplyPluginRequestsOf(program.stage1),
                    ),
                    body
                )
            )
        )
    }

    @Test
    fun `Stage1 only Program is unsupported`() {
        ProgramTarget.values().forEach { programTarget ->

                compilationTrace(projectRoot) {
                    assertScriptCompile(settingsFile.stage1)
                    assertNoScriptCompile(settingsFile.stage2)
                    assertNoScriptCompile(rootBuildFile.stage1)
                    assertScriptCompile(rootBuildFile.stage2)
                }
                // then: single compilation and classloading
                compilationCache {

            """
                plugins { println("stage 1") }
                print("stage 2")
            """.replaceIndent()
        )

        val fragment = source.fragment(0..6, 8..29)
        val stage1 = Program.Plugins(fragment)
        val stage2 = source.map { it.erase(listOf(fragment.range)) }
        val stagedProgram = Dynamic(
            Static(ApplyPluginRequestsOf(stage1), ApplyBasePlugins),
            stage2

                    )
                }

            val stage2 = remainingSource
                .takeIf { it.text.isNotBlank() }
                ?.let(Program::Script)

            stage1?.let { s1 ->
                stage2?.let { s2 ->
                    Program.Staged(s1, s2)
                } ?: s1
            }
                ?: stage2
                ?: Program.Empty
        }
    }

    private

                ?: compiledScriptClassName
        }
    )

    /**
     * Stage descriptions for build operations.
     *
     * Changes to these constants must be coordinated with the GE team.
     */
    private
    object StableDisplayNameFor {

        const val stage1 = "CLASSPATH"

        const val stage2 = "BODY"
    }

    private
    val stage1ScriptDefinition

        val accessorsClassPathHash = TestHashCodes.hashCodeFrom(0)
        val accessorsClassPath = ClassPath.EMPTY
        val stage1TemplateId = "Settings/TopLevel/stage1"
        val stage2TemplateId = "Settings/TopLevel/stage2"

        val scriptSourceResource = mock<TextResource> {
            on { getText() } doReturn text
        }

        val scriptSource = mock<ScriptSource> {
            on { fileName } doReturn scriptPath