}
            }

            dependencies {
                errorprone("com.google.errorprone:error_prone_core:2.8.0")
            }

            tasks.withType(JavaCompile).configureEach {
                options.fork = true
                options.errorprone {
                    check("DoubleBraceInitialization", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
                }
            }

                allprojects {
                    apply plugin: 'java'

                    // ~25MB
                    ext.memoryHog = new byte[1024*1024*25]

                    tasks.withType(JavaCompile).configureEach {
                        options.fork = true
                        options.forkOptions.jvmArgs << "-Dcounter=" + project.property("counter")
                    }
                }
            """
        }

tasks.register('tar', Tar) {
    from 'src/dist'
    into('libs') {
        from configurations.runtimeClasspath
    }
}
// end::tar[]

// tag::reproducible[]
tasks.withType(AbstractArchiveTask).configureEach {
    preserveFileTimestamps = false
    reproducibleFileOrder = true
}

    id("gradlebuild.publish-public-libraries")

    embeddedKotlin("plugin.serialization")
}

description = "The evaluation pipeline for the Declarative language"

tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        apiVersion.set(KotlinVersion.KOTLIN_1_9)
        languageVersion.set(KotlinVersion.KOTLIN_1_9)
    }
}

dependencies {
    api(project(":declarative-dsl-api"))

// TODO why can't we use properties instead of setters here?
// when using them, we get "Cannot access 'preserveFileTimestamps': it is private in 'AbstractArchiveTask'"
// tag::reproducible[]
tasks.withType<AbstractArchiveTask>().configureEach {
    isPreserveFileTimestamps = false
    isReproducibleFileOrder = true
}

        }
    }
// tag::enable-build-id[]
}
// end::configure-publishing[]
// end::enable-build-id[]

// tag::configure-generate-task[]
tasks.withType<GenerateMavenPom>().configureEach {
    val matcher = Regex("""generatePomFileFor(\w+)Publication""").matchEntire(name)
    val publicationName = matcher?.let { it.groupValues[1] }

| Use `withType().configureEach()` instead.

| link:{javadocPath}/org/gradle/api/DomainObjectCollection.html#all-org.gradle.api.Action-[DomainObjectCollection.all()]
| Use `configureEach()` instead.

| link:{javadocPath}/org/gradle/api/DomainObjectCollection.html#whenObjectAdded-org.gradle.api.Action-[DomainObjectCollection.whenObjectAdded()]
| Use `configureEach()` instead.

}

sourceSets {
    "main" { projectDefault() }
    "test" {
        projectDefault()
        generatedTestDir()
    }
}

tasks.withType<KotlinJvmCompile>().configureEach {
    compilerOptions {
        optIn.addAll(
            listOf(
                "kotlin.RequiresOptIn",
                "org.jetbrains.kotlin.analysis.api.KaAnalysisApiInternals",

import gradlebuild.buildutils.tasks.UpdateKotlinVersions
import gradlebuild.buildutils.tasks.UpdateReleasedVersions
import java.net.URL


tasks.withType<UpdateReleasedVersions>().configureEach {
    releasedVersionsFile = releasedVersionsFile()
    group = "Versioning"
}

tasks.register<UpdateReleasedVersions>("updateReleasedVersions") {
    currentReleasedVersion = ReleasedVersion(

        given:
        buildFile << """
            plugins {
                id 'java'
            }
            ${dependsOnPidCapturingAnnotationProcessor}
            tasks.withType(JavaCompile).configureEach {
                options.fork = true
            }
        """
        file('src/main/java/Foo.java') << blockingFooClass
        def handler = blockingHttpServer.expectAndBlock("/block")

        when: