Gradle, how to publish jdk8 variant with a Kotlin library

user_1047713 0
Viewed 347

Long short story: I'd like to publish a variant for jdk8 retro-compatibility for one of my kotlin-only libraries.

This is a long-wanted feature which I'm trying to tackle since quite some time but never got it right. However after many attempts and help on Gradle Slack, I think I'm quite close but I still have an error I can't seem to get rid off.

The idea is to have the main version (src/main and scr/jpms, with this latter containing simply module-info.class) compiled with jdk11, while having a jdk8 variant for src/main only compiled of course with jdk8.

This is my current build.gradle.kts:

import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    kotlin("jvm") version "1.5.10"
    `java-library`
    `maven-publish`
}

group = "kotlin.graphics"
version = "3.3.1"

repositories {
    mavenCentral()
}

dependencies {

    implementation(kotlin("stdlib-jdk8"))

    testImplementation("io.kotest:kotest-runner-junit5:4.4.1")
    testImplementation("io.kotest:kotest-assertions-core:4.4.1")
}


val jdk8 = sourceSets.create("jdk8") {
    java.srcDir("src/main/java")
    kotlin.srcDir("src/main/kotlin")
}

val jdk11 = sourceSets["main"].apply {
    java.srcDir("src/jpms/java")
}

java.registerFeature("jdk8") {
    usingSourceSet(jdk8)
    capability("group", "name", "0.1")
}

configureCompileVersion(jdk8, 8)
configureCompileVersion(jdk11, 11)

val moduleName = "$group.$name"

fun configureCompileVersion(set: SourceSet, jdkVersion: Int) {
    val compiler = project.javaToolchains.compilerFor {
        languageVersion.set(JavaLanguageVersion.of(jdkVersion))
    }.get()
    val target = if (jdkVersion == 8) "1.8" else jdkVersion.toString()
    tasks {
        named<KotlinCompile>(set.compileKotlinTaskName) {
            kotlinOptions {
                jvmTarget = target
                jdkHome = compiler.metadata.installationPath.asFile.absolutePath
            }
            source = sourceSets.main.get().kotlin
        }
        named<JavaCompile>(set.compileJavaTaskName) {
            targetCompatibility = target
            sourceCompatibility = target
            modularity.inferModulePath.set(jdkVersion >= 9)
            javaCompiler.set(compiler)
            source = sourceSets.main.get().allJava + set.allJava
            if (jdkVersion >= 9)
                options.compilerArgs = listOf("--patch-module", "$moduleName=${set.output.asPath}")
        }
    }
}

val SourceSet.compileKotlinTaskName: String
    get() = getCompileTaskName("kotlin")

val SourceSet.kotlin: SourceDirectorySet
    get() = withConvention(KotlinSourceSet::class) { kotlin }

publishing {
    publications {
        create<MavenPublication>("maven") {
            groupId = "org.gradle.sample"
            artifactId = "library"
            version = "1.1"

            from(components["java"])
        }
    }
    repositories.maven {
        name = "prova"
        url = uri("repo")
    }
}

If I run :assemble, the produced artifact is compiled properly with jdk11. And till that everything as expected. But If I try to publish, I get instead:

Task :compileJdk8Kotlin FAILED 5 actionable tasks: 1 executed, 4 up-to-date e: Module java.base cannot be found in the module graph

For some reasons, it looks like Gradle tries to compile the jdk8 variant using jpms, although it should be disabled automatically. I tried to manually set it on and off:

modularity.inferModulePath.set(jdkVersion >= 9)

but it didn't work neither.

The project is here

Gradle 7.1.1

gradle-kotlin-dsl java-platform-module-system kotlin build.gradle gradle
1 Answers

I think I got it


// these two are simple helpers

val SourceSet.compileKotlinTaskName: String
    get() = getCompileTaskName("kotlin")

val SourceSet.kotlin: SourceDirectorySet
    get() = project.extensions.getByType<KotlinJvmProjectExtension>().sourceSets.getByName(name).kotlin

// pick the `main` sourceSet and use it for jdk11
val jdk11 = sourceSets.main.get()

// now we clone `main` into `jdk8`, with the only difference being the exclusion 
// of `module-info.class`. We need to call `::create` to avoid getting the 
// reference to the same sourceSet.
val jdk8 = sourceSets.create("jdk8") {
    // this is superfluous, adding not-existing folders is harmless, but it's 
    // rather confusing when you need to debug two sourceSet java/kotlin
    java.setSrcDirs(emptySet<File>())
    kotlin.setSrcDirs(emptySet<File>())
    // assign the very same source directories
    java.setSrcDirs(jdk11.java.srcDirs)
    kotlin.setSrcDirs(jdk11.kotlin.srcDirs)
    // exclude the file from both, since kotlin includes always the java sources
    java.setExcludes(listOf("module-info.java"))
    kotlin.setExcludes(listOf("module-info.java"))
}

// this will create the `jdk8` variant using the given sourceSet at the given
// capabilities
java.registerFeature("jdk8") {
    usingSourceSet(jdk8)
    // I experienced `version` to be `null` if it's declared in the 
    // build.gradle.kts, then I moved it into `settings.gradle.kts to fix this
    capability(group.toString(), name, version.toString())
}

// set everything for each variant, jdk11 is the default/main one
configureCompileVersion(jdk8, 8)
configureCompileVersion(jdk11, 11)

val moduleName = "$group.$name"

fun configureCompileVersion(set: SourceSet, jdkVersion: Int) {
    tasks {
        val target = if (jdkVersion == 8) "1.8" else jdkVersion.toString()
        // we do need the task name because we have compileKotlin and
        // jdk8CompileKotlin and we want to set stuff accordingly
        named<KotlinCompile>(set.compileKotlinTaskName) {
            targetCompatibility = target
            sourceCompatibility = target
            kotlinOptions {
                // jdkHome is deprecated in 1.5.30
                jvmTarget = target
                // this is outside the variant scope
                freeCompilerArgs += listOf("-Xinline-classes", "-Xopt-in=kotlin.RequiresOptIn")
            }
            source = sourceSets.main.get().kotlin
        }
        named<JavaCompile>(set.compileJavaTaskName) {
            targetCompatibility = target
            sourceCompatibility = target
            // this is supposed to be set automatically, well with a jdk8 variant
            // you need to set it up explicitly
            modularity.inferModulePath.set(jdkVersion >= 9)
            javaCompiler.set(project.javaToolchains.compilerFor {
                languageVersion.set(JavaLanguageVersion.of(jdkVersion))
            }.get())
            source = set.allJava
            if (jdkVersion >= 9)
                options.compilerArgs = listOf("--patch-module", "$moduleName=${set.output.asPath}")
        }
        withType<Test> { useJUnitPlatform() }
    }
}

// We also want to automatically set all the jdk11 dependencies to jdk8 as well
configurations {
    named("jdk8Implementation") {
        extendsFrom(implementation.get())
    }
}
user_10477130
Related