id("org.acme.my-other-plugin") version "1.0"
            }
            """
        )

        val initScript =
            withFile(
                "my-init-script.init.gradle.kts",
                """

                initscript {
                    $repositoriesBlock
                    dependencies {
                        classpath("org.acme:plugins:1.0")

    private
    fun countUpToDatePrefixOf(
        previous: List<ConfigurationCacheFingerprint.InputFile>,
        current: List<File>
    ): Int = current.zip(previous)
        .takeWhile { (initScript, fingerprint) -> isFileUpToDate(initScript, fingerprint.hash) }
        .count()

    private
    fun checkFingerprintValueIsUpToDate(obtainedValue: ObtainedValue): InvalidationReason? {

sealed class Program {

    /**
     * A program with no observable side-effects.
     */
    object Empty : Program() {

        override fun toString() = "Empty"
    }

    /**
     * A `buildscript` / `initscript` block.
     */
    data class Buildscript(override val fragment: ProgramSourceFragment) : Stage1(), FragmentHolder

    /**
     * A `pluginManagement` block.
     */

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    @Issue("https://issues.gradle.org/browse/GRADLE-2032")
    def "can simultaneously run gradle on projects with buildSrc"() {
        initScript """
            import ${BuildOperationListenerManager.name}
            import ${BuildOperationListener.name}
            import ${BuildOperationDescriptor.name}
            import ${OperationStartEvent.name}

    @Issue('gradle/gradle-native#206')
    @ToBeFixedForConfigurationCache
    def 'can define and use source repositories with initscript resolution present'() {
        given:
        def commit = repo.commit('initial commit')
        temporaryFolder.file('initialize.gradle') << """
        initscript {
            dependencies {
                classpath files('classpath.file')
            }
        }

    def "#scriptType script classpath configurations are exposed"() {
        setup:
        def m1 = mavenHttpRepo.module('org.foo', 'root-dep').publish()

        def initScript = file('init.gradle')
        initScript << ''
        executer.usingInitScript(initScript)

        file('scriptPlugin.gradle') << '''
        task foo
        '''

        buildFile << '''
        apply from: 'scriptPlugin.gradle'
        '''

            .withTasks("publish")
            .run()
    }

    private ExecutionResult pluginsAppliedWith(GradleDistribution distribution) {
        file("consumer/init.gradle.kts").text = """
            initscript {
                repositories {
                    maven(url = "${mavenRepo.uri}")
                }
                dependencies {
                    classpath("com.example:plugin:1.0")
                }

        """)

        def initScript = file('init-script.gradle') << """
            initscript {
                dependencies {
                    classpath(files("$pluginJar"))
                }
            }

            apply plugin: MyInitPluginPlugin
        """

        when:
        executer.usingInitScript(initScript)

        then:
        succeeds("help")

private
fun KotlinLexer.packageDefinitionFound() = tokenType == KtTokens.PACKAGE_KEYWORD


private
val packageParsingAbortIdentifiers = setOf("import", "buildscript", "plugins", "pluginManagement", "initscript")


private
fun KotlinLexer.tooLateForPackageStatement(): Boolean {
    // based on https://kotlinlang.org/docs/reference/grammar.html#script

        notifications.op(RunRequestedWorkBuildOperationType.Details).parentId == notifications.op(RunBuildBuildOperationType.Details).id
    }

    def "emits for GradleBuild tasks"() {
        when:
        def initScript = file("init.gradle") << """
            if (parent == null) {
                ${notifications.registerListener()}
            }
        """
        settingsFile << "rootProject.name = 'parent'"