tasks.withType<JavaCompile>().configureEach {
            options.compilerArgs.add("-Xlint:-deprecation")
        }
    }

    fun ignoreRawTypes() {
        tasks.withType<JavaCompile>().configureEach {
            options.compilerArgs.add("-Xlint:-rawtypes")
        }
    }

    fun ignoreAnnotationProcessing() {
        tasks.withType<JavaCompile>().configureEach {

}

tasks.withType<GroovyCompile>().configureEach {
    groovyOptions.apply {
        encoding = "utf-8"
        forkOptions.jvmArgs?.add("-XX:+HeapDumpOnOutOfMemoryError")
    }
    options.apply {
        isFork = true
        encoding = "utf-8"
        compilerArgs = mutableListOf("-Xlint:-options", "-Xlint:-path")
    }
}

tasks.withType<Test>().configureEach {

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(
        project.providers.environmentVariable("PGP_SIGNING_KEY").orNull,
        project.providers.environmentVariable("PGP_SIGNING_KEY_PASSPHRASE").orNull
    )
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)
        }
    }

            compatibilityRules.add(NullawayCompatibilityRule::class.java)
        }
    }
}

project.plugins.withType<JavaBasePlugin> {
    project.extensions.getByName<SourceSetContainer>("sourceSets").configureEach {
        val isMainSourceSet = (name == "main")

        val extension = this.extensions.create<ErrorProneSourceSetExtension>(
            "errorprone",
            project.objects.property<Boolean>()

val signArtifacts: Boolean = !pgpSigningKey.orNull.isNullOrEmpty()

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(pgpSigningKey.orNull, pgpSigningPassPhrase.orNull)
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)
        }
    }

    testImplementation("org.junit.vintage:junit-vintage-engine")

    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.withType<KotlinCompile>().configureEach {
    compilerOptions {
        allWarningsAsErrors = true
    }
}

detekt {
    // overwrite the config file's location

val artifactoryUserPassword
    get() = project.providers.gradleProperty("artifactoryUserPassword").orNull

tasks.withType<AbstractPublishToMaven>().configureEach {
    val noUpload = project.gradleProperty("noUpload")
    this.onlyIf { !noUpload.map { it == "true" }.orElse(false).get() }
    if (name.endsWith("ToRemoteRepository")) {
        failEarlyIfUrlOrCredentialsAreNotSet(this)

import gradlebuild.integrationtests.tasks.IntegrationTest

plugins {
    id("gradlebuild.integration-tests")
}

tasks.withType<IntegrationTest>().configureEach {
    // See AbstractKotlinIntegrationTest
    "kotlinDslTestsExtraRepo".let { propName ->
        System.getProperty(propName)?.let { systemProperty(propName, it) }
    }
}

dependencies {
    integTestRuntimeOnly(project(":kotlin-dsl-plugins")) {

plugins {
    id("gradlebuild.module-identity")
}

tasks.named<UpdateDaemonJvm>("updateDaemonJvm") {
    languageVersion = JavaLanguageVersion.of(17)
}

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

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

// to compile to different JVM versions.

val jvmCompile = extensions.create<JvmCompileExtension>(JvmCompileExtension.NAME)

jvmCompile.compilations.configureEach {
    // Assume the compilation does not use any workarounds
    usesJdkInternals = false
    usesFutureStdlib = false

    // All compilations must have a target JVM version configured explicitly.