xref: /aosp_15_r20/external/kotlinx.atomicfu/atomicfu/build.gradle (revision 68017707106cb9da9fed635c150bc497c09c160f)

/*
 * Copyright 2016-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
 */

import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile

apply plugin: 'kotlin-multiplatform'
apply from: rootProject.file("gradle/targets.gradle")

ext {
    nativeMainSets = []
    nativeTestSets = []
    nativeCompilations = []

    addNative = { preset ->
        nativeMainSets.add(preset.compilations['main'].kotlinSourceSets.first())
        nativeTestSets.add(preset.compilations['test'].kotlinSourceSets.first())
        nativeCompilations.add(preset.compilations['main'])
    }
}


kotlin {
    targets {
        delegate.metaClass.addTarget = { preset ->
            addNative(delegate.fromPreset(preset, preset.name))
        }
    }

    // JS -- always
    js(IR) {
        moduleName = "kotlinx-atomicfu"
        // TODO: commented out because browser tests do not work on TeamCity
        // browser()
        nodejs()
    }

    // JVM -- always
    jvm()

    // Wasm -- always
    wasmJs {
        nodejs()
    }

    wasmWasi {
        nodejs()
    }

    sourceSets {
        commonMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-common'
            }
        }
        commonTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-common'
                implementation 'org.jetbrains.kotlin:kotlin-test-annotations-common'
            }
        }

        jsAndWasmSharedMain {
            dependsOn(sourceSets.commonMain)
        }

        jsMain {
            dependsOn(sourceSets.jsAndWasmSharedMain)
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-js'
            }
        }
        jsTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-js'
            }
        }

        wasmJsMain {
            dependsOn(sourceSets.jsAndWasmSharedMain)
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-wasm-js'
            }
        }

        wasmJsTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-wasm-js'
            }
        }

        wasmWasiMain {
            dependsOn(sourceSets.jsAndWasmSharedMain)
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-wasm-wasi'
            }
        }
        wasmWasiTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-test-wasm-wasi'
            }
        }

        jvmMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib'
            }
        }
        jvmTest {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-reflect'
                implementation 'org.jetbrains.kotlin:kotlin-test'
                implementation 'org.jetbrains.kotlin:kotlin-test-junit'
                implementation "junit:junit:$junit_version"
            }
        }
    }
}

// configure native targets only if they're not disabled
if (rootProject.ext.native_targets_enabled) {
    kotlin {
        targets {
            if (project.ext.ideaActive) {
                addNative(fromPreset(project.ext.ideaPreset, 'native'))
            } else {
                // Support of all non-deprecated targets from official tier list: https://kotlinlang.org/docs/native-target-support.html

                // Tier #1
                addTarget(presets.linuxX64)
                addTarget(presets.macosX64)
                addTarget(presets.macosArm64)
                addTarget(presets.iosSimulatorArm64)
                addTarget(presets.iosX64)

                // Tier #2
                addTarget(presets.linuxArm64)
                addTarget(presets.watchosSimulatorArm64)
                addTarget(presets.watchosX64)
                addTarget(presets.watchosArm32)
                addTarget(presets.watchosArm64)
                addTarget(presets.tvosSimulatorArm64)
                addTarget(presets.tvosX64)
                addTarget(presets.tvosArm64)
                addTarget(presets.iosArm64)


                // Tier #3
                addTarget(presets.androidNativeArm32)
                addTarget(presets.androidNativeArm64)
                addTarget(presets.androidNativeX86)
                addTarget(presets.androidNativeX64)
                addTarget(presets.mingwX64)
                addTarget(presets.watchosDeviceArm64)
            }
        }

        sourceSets {
            nativeMain { dependsOn commonMain }

            nativeTest {}

            if (!project.ext.ideaActive) {
                configure(nativeMainSets) {
                    dependsOn nativeMain
                }

                configure(nativeTestSets) {
                    dependsOn nativeTest
                }
            }
        }

        configure(nativeCompilations) {
            cinterops {
                interop {
                    defFile 'src/nativeInterop/cinterop/interop.def'
                }
            }
        }
    }
}

configurations {
    transformer
}

apply from: rootProject.file('gradle/compile-options.gradle')

ext.configureKotlin()

dependencies {
    transformer project(":atomicfu-transformer")
}

// ==== CONFIGURE JVM =====

def classesPreAtomicFuDir = file("$buildDir/classes/kotlin/jvm/test")
def classesPostTransformFU = file("$buildDir/classes/kotlin/jvm/postTransformedFU")
def classesPostTransformVH = file("$buildDir/classes/kotlin/jvm/postTransformedVH")
def classesPostTransformBOTH = file("$buildDir/classes/kotlin/jvm/postTransformedBOTH")

tasks.withType(compileTestKotlinJvm.getClass()) {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

task transformFU(type: JavaExec, dependsOn: compileTestKotlinJvm) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerKt"
    args = [classesPreAtomicFuDir, classesPostTransformFU, "FU"]
    classpath = configurations.transformer
    inputs.dir(classesPreAtomicFuDir)
    outputs.dir(classesPostTransformFU)
}

task transformBOTH(type: JavaExec, dependsOn: compileTestKotlinJvm) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerKt"
    args = [classesPreAtomicFuDir, classesPostTransformBOTH, "BOTH"]
    classpath = configurations.transformer
    inputs.dir(classesPreAtomicFuDir)
    outputs.dir(classesPostTransformBOTH)
}

task transformVH(type: JavaExec, dependsOn: compileTestKotlinJvm) {
    main = "kotlinx.atomicfu.transformer.AtomicFUTransformerKt"
    args = [classesPreAtomicFuDir, classesPostTransformVH, "VH"]
    classpath = configurations.transformer
    inputs.dir(classesPreAtomicFuDir)
    outputs.dir(classesPostTransformVH)
}

task transformedTestFU_current(type: Test, dependsOn: transformFU) {
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformFU)
    testClassesDirs = project.files(classesPostTransformFU)
    exclude '**/*LFTest.*', '**/TraceToStringTest.*', '**/AtomicfuReferenceJsTest.*'
    filter { setFailOnNoMatchingTests(false) }
}

task transformedTestBOTH_current(type: Test, dependsOn: transformBOTH) {
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformBOTH)
    testClassesDirs = project.files(classesPostTransformBOTH)
    exclude '**/*LFTest.*', '**/TraceToStringTest.*', '**/TopLevelGeneratedDeclarationsReflectionTest.*', '**/SyntheticFUFieldsTest.*', '**/AtomicfuReferenceJsTest.*'
    filter { setFailOnNoMatchingTests(false) }
}

task transformedTestVH(type: Test, dependsOn: transformVH) {
    classpath = files(configurations.jvmTestRuntimeClasspath, classesPostTransformVH)
    testClassesDirs = project.files(classesPostTransformVH)
    exclude '**/*LFTest.*', '**/TraceToStringTest.*', '**/TopLevelGeneratedDeclarationsReflectionTest.*', '**/SyntheticFUFieldsTest.*', '**/AtomicfuReferenceJsTest.*'
    filter { setFailOnNoMatchingTests(false) }
}

transformedTestVH.onlyIf {
    logger.println(JavaVersion.current())
    JavaVersion.current().ordinal() >= JavaVersion.VERSION_1_9.ordinal()
}

task jvmTestAll(dependsOn: [
    transformedTestFU_current,
    transformedTestBOTH_current,
    transformedTestVH
])

tasks.withType(Test) {
    testLogging {
        showStandardStreams = true
        events "passed", "failed"
    }
}

task compileJavaModuleInfo(type: JavaCompile) {
    def moduleName = "kotlinx.atomicfu" // this module's name
    def compilation = kotlin.targets["jvm"].compilations["main"]
    def compileKotlinTask = compilation.compileTaskProvider.get() as KotlinJvmCompile
    def targetDir = compileKotlinTask.destinationDirectory.dir("../java9")
    def sourceDir = file("src/jvmMain/java9/")

    // Use a Java 11 compiler for the module info.
    javaCompiler.set(project.javaToolchains.compilerFor { languageVersion.set(JavaLanguageVersion.of(11)) })

    // Always compile kotlin classes before the module descriptor.
    dependsOn(compileKotlinTask)

    // Add the module-info source file.
    source(sourceDir)

    // Also add the module-info.java source file to the Kotlin compile task.
    // The Kotlin compiler will parse and check module dependencies,
    // but it currently won't compile to a module-info.class file.
    // Note that module checking only works on JDK 9+,
    // because the JDK built-in base modules are not available in earlier versions.
    def javaVersion = compileKotlinTask.kotlinJavaToolchain.javaVersion.getOrNull()
    if (javaVersion?.isJava9Compatible() == true) {
        logger.info("Module-info checking is enabled; $compileKotlinJvm is compiled using Java $javaVersion")
        compileKotlinJvm.source(sourceDir)
    } else {
        logger.info("Module-info checking is disabled")
    }

    // Set the task outputs and destination dir
    outputs.dir(targetDir)
    destinationDirectory.set(targetDir)

    // Configure JVM compatibility
    sourceCompatibility = JavaVersion.VERSION_1_9.toString()
    targetCompatibility = JavaVersion.VERSION_1_9.toString()

    // Set the Java release version.
    options.release.set(9)

    // Ignore warnings about using 'requires transitive' on automatic modules.
    // not needed when compiling with recent JDKs, e.g. 17
    options.compilerArgs.add("-Xlint:-requires-transitive-automatic")

    // Patch the compileKotlinJvm output classes into the compilation so exporting packages works correctly.
    options.compilerArgs.addAll(["--patch-module", "$moduleName=${compileKotlinTask.destinationDirectory.get().getAsFile()}"])

    // Use the classpath of the compileKotlinJvm task.
    // Also ensure that the module path is used instead of classpath.
    classpath = compileKotlinTask.libraries
    modularity.inferModulePath.set(true)

    doFirst {
        logger.warn("Task destination directory: ${destinationDirectory.get().getAsFile()}")
    }
}

// Configure the JAR task so that it will include the compiled module-info class file.
tasks.named("jvmJar") {
    manifest {
        attributes(["Multi-Release": true])
    }
    from(compileJavaModuleInfo.destinationDirectory) {
        into("META-INF/versions/9/")
    }
}

jvmTest {
    exclude "**/AtomicfuBytecodeTest*", "**/AtomicfuReferenceJsTest*", '**/TopLevelGeneratedDeclarationsReflectionTest.*', '**/SyntheticFUFieldsTest.*' // run them only for transformed code
}

jvmTest.dependsOn jvmTestAll

afterEvaluate {
    publishing.publications {
        kotlinMultiplatform {
            apply from: "$rootDir/gradle/publish-mpp-root-module-in-platform.gradle"
            publishPlatformArtifactsInRootModule(jvm)
        }
    }
}

tasks.matching { it.name == "generatePomFileForKotlinMultiplatformPublication" }.configureEach {
    dependsOn(tasks["generatePomFileForJvmPublication"])
}

// Workaround for https://youtrack.jetbrains.com/issue/KT-58303:
// the `clean` task can't delete the expanded.lock file on Windows as it's still held by Gradle, failing the build
tasks.clean {
    setDelete(layout.buildDirectory.asFileTree.matching {
        exclude("tmp/.cache/expanded/expanded.lock")
    })
}