Use Gradle sub-projects with Kotlin multiplatform

Question

I'm using Kotlin multi-platform (JVM & JS), which in IDEA creates three projects: demo, demo-js and demo-jvm.

I would like to split the common code into more subprojects/submodules. Let's say I add commonmod; how do I make it compile?

The error right now, for gradle run -p demo-jvm, is:

demo/demo-js/src/main/kotlin/demo/commonmod/example.kt: (3, 12): Actual function 'getPlatform' has no corresponding expected declaration

but I think I'm doing this fundamentally wrong, as I don't know what should depend on what (although I tried quite some iterations). If I solve this error I get other ones, and then other ones again, until I'm back to this one.

---

As a minimal-but-still-large example, I have:

demo/settings.gradle:

rootProject.name = 'demo'

include 'demo-jvm', 'demo-js', 'commonmod'

demo/build.gradle:

buildscript { ... }

apply plugin: 'kotlin-platform-common'

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-common:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test-annotations-common:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test-common:$kotlin_version"
    compile project(':commonmod')
}

demo/demo-jvm/settings.gradle:

rootProject.name = 'demo'

demo/demo-jvm/build.gradle:

buildscript { ... }

apply plugin: 'kotlin-platform-jvm'
apply plugin: 'application'

repositories {
    mavenCentral()
}

mainClassName = "demo.MainKt"

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    expectedBy project(":")
    testCompile "junit:junit:4.12"
    testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
}

demo/demo-js/settings.gradle:

rootProject.name = 'demo'

demo/demo-js/build.gradle:

buildscript { ... }

apply plugin: 'kotlin-platform-js'

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-js:$kotlin_version"
    expectedBy project(":")
    testCompile "org.jetbrains.kotlin:kotlin-test-js:$kotlin_version"
}

demo/commonmod/settings.gradle:

rootProject.name = 'demo'

include 'demo-jvm', 'demo-js'

demo/commonmod/build.gradle:

buildscript { ... }

apply plugin: 'kotlin-platform-common'

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-common:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test-annotations-common:$kotlin_version"
    testCompile "org.jetbrains.kotlin:kotlin-test-common:$kotlin_version"
    compile project(':demo-js')
    compile project(':demo-jvm')
}

Answer 1

This took a crazy amount of time, so I hope this is useful for someone!

There is a functional example on Github: kotlin_multiplatform_gradle_demo

Several sources helped, but a lot of it was trial and error, so if something is bad practise, please let me know!

---

For the minimal example, the structure is like this:

├── alpha
│   ├── alpha-js
│   │   └── build.gradle
│   ├── alpha-jvm
│   │   └── build.gradle
│   ├── build.gradle
│   └── src
│       └── main
│           ├── kotlin
│           │   └── demo
│           │       └── alpha
│           │           └── main.kt
├── beta
│   ├── beta-js
│   │   ├── build.gradle
│   │   └── src
│   │       └── main
│   │           └── kotlin
│   │               └── demo
│   │                   └── beta
│   │                       └── platform.kt
│   ├── beta-jvm
│   │   ├── build.gradle
│   │   └── src
│   │       └── main
│   │           └── kotlin
│   │               └── demo
│   │                   └── beta
│   │                       └── platform.kt
│   ├── build.gradle
│   └── src
│       └── main
│           └── kotlin
│               └── demo
│                   └── beta
│                       └── platform.kt
├── build.gradle
└── settings.gradle

The common modules (alpha and beta) need platform modules for each platform with at least a `build.gradle``.

The settings.gradle file imports all modules, including platform ones.

Dependencies, e.g. from alpha on beta, is declared in the common alpha module and all alpha platform modules.

---

Some patterns I learned:

• Every 'normal' (common) module has one platform module for each platform.
• For common module alpha, the javascript platform module must be called alpha-js (similar for -jvm).
• If there is no platform specific code, this module can be just a gradle file in a directory.
• The platform modules can be conveniently placed inside of the common module directory (so alpha:alpha-js).
• The common module should not refer to the platform modules; the platform modules have a dependency expectedBy project(":the_common_module").

• If module alpha depends on beta, then

  • alpha must have dependencies { compile project(":beta") }
  • alpha-js must have dependencies { compile project(":beta:beta-js") } (in addition to expectedBy)
  • alpha-jvm must have dependencies { compile project(":beta:beta-jvm") } (in addition to expectedBy) etc

• Only the top module has settings.gradle, which includes ALL submodules (including platform ones).

• Make sure to get the names right, as incorrect ones don't cause an error, they just fail silently. (It seems ridiculous but I guess there is a reason.)
• Do NOT put all the output into a single, shared build directory - this results in several weird non-deterministic errors.

---

I used to have the full config files here, but it's better to just check the code on Github because it's really long.

Answer 2

For anyone coming from a Google search for:

"Actual function/class/companion object/etc. has no corresponding expected declaration"

Try cleaning and rebuilding the project, for me, this revealed a number of other errors which were preventing the build.

Answer 3

Submodules have to be declared within the scope of dependencies by sourceSets. If the submodule is defined in the common sourceSet, it does not need to be defined in the one of the particular platform, but not vice versa.

build.gradle.kts (:kmm_shared:feature_a)

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                api(project(":kmm_shared:domain"))
            }
        }
}

With this it is not necessary that the android sourceSet also includes the dependency.

GL