"Unexpected operation `$description`!"
        }
    }

    private
    fun operationDescription(stage: CachedScript.CompilationStage) =
        "Compile script ${stage.file.name} (${descriptionOf(stage)})"

    private
    fun descriptionOf(stage: CachedScript.CompilationStage) =
        if (stage.stage == "stage1") "CLASSPATH" else "BODY"

            val source: Program.Plugins? = null
        ) : StageTransition, Instruction()

        /**
         * An instruction that marks the transition from stage 1 to stage 2 by causing the
         * target scope to be closed thus making the resolved classpath available to stage 2.
         *
         * A valid [Static] program must contain one and only one [StageTransition] instruction.
         */
        interface StageTransition

private
fun pluginsBlockOf(program: Program): Program.Plugins? =
    when (program) {
        is Program.Plugins -> program
        is Program.Stage1Sequence -> program.plugins
        is Program.Staged -> pluginsBlockOf(program.stage1)
        else -> null
    }


private
fun parse(scriptPlugin: PrecompiledScriptPlugin): Program = ProgramParser.parse(
    ProgramSource(scriptPlugin.scriptFileName, scriptPlugin.scriptText),

    }
}


@VisibleForTesting
fun templateIdFor(programTarget: ProgramTarget, programKind: ProgramKind, stage: String): String =
    programTarget.name + "/" + programKind.name + "/" + stage


private
fun classLoaderScopeIdFor(scriptPath: String, stage: String) =
    "kotlin-dsl:$scriptPath:$stage"


private

            if (smokeTests.size > 1) {
                buildType(PartialTrigger("All Smoke Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_SmokeTests", model, smokeTests))
            }
            if (crossVersionTests.size > 1) {
                buildType(PartialTrigger("All Cross-Version Tests for ${stage.stageName.stageName}", "Stage_${stage.stageName.id}_CrossVersionTests", model, crossVersionTests))
            }

        assertProgramOf(
            source,
            Program.Buildscript(source.fragment(1..11, 13..34))
        )
    }

    @Test
    fun `non-empty Stage 1 with non-empty Stage 2 parse to Stage 1 followed by Stage 2`() {

        val source = ProgramSource(
            "/src/fragment.gradle.kts",
            "\r\n\r\nplugins {\r\n  java\r\n}\r\nprintln(\"Stage 2\")\r\n\r\n"
        )

import org.junit.Test


class ProgramParserAnnotationErasureTest {

    @Test
    fun `empty Stage 1 with non-empty Stage 2 parse to Stage 2 with Stage 1 fragments erased`() {
        val scriptOnlySource =
            programSourceWith("""
                @Suppress("unused_variable")
                println("Stage 2")""".trimIndent())

        assertProgramOf(
            scriptOnlySource,

            val stage = model.stages[stageNumber - 1]
            val prevStage = if (stageNumber > 1) model.stages[stageNumber - 2] else null

            if (stage.runsIndependent) {
                return@forEach
            }

            assertEquals(
                stage.specificBuilds.size + stage.functionalTests.size + stage.performanceTests.size + stage.docsTests.size + (if (prevStage != null) 1 else 0),

            "stage 1 buildscript\nstage 1 plugins\n"
        )
    }

    @Test
    fun `pluginManagement then buildscript then plugins`() {
        val source = ProgramSource(
            "settings.gradle.kts",
            """
            pluginManagement { println("stage 1 pluginManagement") }
            buildscript { println("stage 1 buildscript") }
            plugins { println("stage 1 plugins") }

import model.CIBuildModel
import model.Stage
import model.StageName
import model.Trigger
import projects.StageProject

class StagePasses(model: CIBuildModel, stage: Stage, prevStage: Stage?, stageProject: StageProject) : BaseGradleBuildType(init = {
    id(stageTriggerId(model, stage))
    uuid = stageTriggerUuid(model, stage)
    name = stage.stageName.stageName + " (Trigger)"
    type = Type.COMPOSITE