no build output compiled for common module of Kotlin Multiplatform project

Question

I'm trying to figure out why dependent projects for my Kotlin MPP library don't see any provided modules in their common modules even though the targets (jvm, android) can see them.

Published via maven-publish.

The /build directory for the library contains nothing I can identify as an intermediate representation of my common modules, leading me to think that I need to explicitly tell Gradle to produce the files to be included as common in the published package.

As it is, the .aar and .jar files produced in the android and desktop (jvm) modules each look normal, but the published common module is empty.

I need that common module to be populated before I can code against it inside the common module of dependent projects.

Here is the relevant section of my build.gradle.kts. I omit the repository config as it appears to work.

I basically followed the instructions from kotlinlang.org.

I've looked at the maven-publish plugin configuration, the settings for the kotlin-multiplatformm plugin, and the configured project structure.

kotlin version is 1.6.10, unable to update due to Jetbrains Compose dependency.

plugins {
    kotlin("multiplatform")
    id("com.android.library")
    id("maven-publish")
}

kotlin {
    android {
        publishLibraryVariants = listOf("release", "debug")
    }

    jvm("desktop") {
        compilations.all {
            kotlinOptions {
                jvmTarget = "11"
            }
        }
    }

    val publicationsFromMainHost = listOf(jvm("desktop").name, "kotlinMultiplatform")

    publishing {
        publications {
            matching { it.name in publicationsFromMainHost }.all {
                val targetPublication = this@all
                tasks.withType<AbstractPublishToMaven>()
                    .matching { it.publication == targetPublication }
            }
        }
    }

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.3.2")
            }
        }
        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
            }
        }
        val androidMain by getting {
            dependencies {
                implementation("androidx.startup:startup-runtime:1.1.1")
            }
        }
        val androidTest by getting {
            dependencies {
                implementation("junit:junit:4.13.2")
                implementation("androidx.test:core:1.4.0")

                implementation("androidx.test:runner:1.4.0")
                implementation("androidx.test:rules:1.4.0")

                implementation("org.robolectric:robolectric:4.6.1")
            }
        }
        val desktopMain by getting
        val desktopTest by getting {
            dependencies {
                implementation("junit:junit:4.13.2")

            }
        }
    }
}

Answer 1

The answer is to manually supply the Kotlin stdlib dependency, rather than relying on the gradle plugin to add it.

When there are only jvm-based builds present, commonMain will be built with platform type of jdk8 rather than common. By making an explicit dependency on stdlib-common, it will be coerced back to the common platform, and then the correct metadata will be created and published.

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(kotlin("stdlib-common"))
            }
        }
    }

}