Initial multiplatform exploration

.github/workflows/ci.yml

@@ -53,7 +53,11 @@ jobs:
           java-version: ${{ matrix.java-version }}
 
       - name: Test
-        run: ./gradlew check jacocoTestReport
+        # Running check and jacocoTestReport together results in incorrect coverage (or no coverage)
+        # Running them separately runs the jvmTests twice, which is weird, but results in correct coverage
+        run: |
+          ./gradlew check
+          ./gradlew jacocoTestReport
 
       - name: Danger
         # Run Danger for PRs originating from within the repo (for fork PRs the token won't give permission to comment)

Dangerfile

@@ -1 +1 @@
-shroud.report 'build/reports/jacoco/test/jacocoTestReport.xml', 80, 80, false
+shroud.report 'build/reports/jacoco/jacocoTestReport/jacocoTestReport.xml', 80, 80, false

build.gradle.kts

@@ -1,7 +1,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 plugins {
-    kotlin("jvm") version Versions.kotlin
+    kotlin("multiplatform") version Versions.kotlin apply false
     jacoco
     id("io.gitlab.arturbosch.detekt") version Versions.detekt
     id("org.jetbrains.dokka") version Versions.dokka
@@ -16,88 +16,23 @@ allprojects {
 }
 
 subprojects {
-    apply {
-        plugin<org.jetbrains.kotlin.gradle.plugin.KotlinPluginWrapper>()
-        plugin<JacocoPlugin>()
-        plugin<io.gitlab.arturbosch.detekt.DetektPlugin>()
-        plugin<org.jetbrains.dokka.gradle.DokkaPlugin>()
-    }
-
-    dependencies {
-        detektPlugins(Dependencies.detektFormatting)
-    }
-
-    java {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
-
-    kotlin {
-        explicitApi()
-    }
-
     tasks {
-        compileKotlin {
+        withType<org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile>().configureEach {
             kotlinOptions {
                 jvmTarget = JavaVersion.VERSION_1_8.toString()
-                allWarningsAsErrors = true
             }
         }
-
-        compileTestKotlin {
+        withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
             kotlinOptions {
-                jvmTarget = JavaVersion.VERSION_1_8.toString()
+                freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"
                 allWarningsAsErrors = true
             }
         }
 
-        test {
-            useJUnitPlatform()
-        }
-
-        jacoco {
-            toolVersion = Versions.jacoco
-        }
-
-        jacocoTestReport {
-            dependsOn(test)
-
-            reports {
-                html.isEnabled = true
-                xml.isEnabled = true
-            }
-        }
-
-        withType<io.gitlab.arturbosch.detekt.Detekt> {
-            jvmTarget = JavaVersion.VERSION_1_8.toString()
-        }
-
-        check {
-            dependsOn("detektMain")
-        }
-
-        dokkaHtml {
-            outputDirectory.set(javadoc.get().destinationDir)
-        }
-
         plugins.withType(MavenPublishPlugin::class) {
-            val sourcesJar by creating(Jar::class) {
-                archiveClassifier.set("sources")
-                from(sourceSets.main.get().allSource)
-            }
-
-            val javadocJar by creating(Jar::class) {
-                archiveClassifier.set("javadoc")
-                from(dokkaHtml)
-            }
-
             publishing {
                 publications {
                     create<MavenPublication>("default") {
-                        from(this@subprojects.components["java"])
-                        artifact(sourcesJar)
-                        artifact(javadocJar)
-
                         pom {
                             name.set(project.name)
                             description.set("Obsoleting enums with sealed classes of objects")
@@ -143,22 +78,52 @@ apiValidation {
 
 tasks {
     val jacocoMergeTest by registering(JacocoMerge::class) {
-        dependsOn(subprojects.map { it.tasks.jacocoTestReport })
+        dependsOn(subprojects.mapNotNull { it.tasks.findByName("jacocoTestReport") })
 
-        destinationFile = file("$buildDir/jacoco/test.exec")
-        executionData = fileTree(rootDir) {
-            include("**/build/jacoco/test.exec")
-        }
+        destinationFile = file("$buildDir/jacoco/jvmTest.exec")
+
+        executionData(
+            subprojects.filter { it.tasks.findByName("jacocoTestReport") != null }.map {
+                "${it.buildDir}/jacoco/jvmTest.exec"
+            }
+        )
     }
 
-    jacocoTestReport {
+    val jacocoTestReport by registering(JacocoReport::class) {
         dependsOn(jacocoMergeTest)
 
-        sourceSets(*subprojects.map { it.sourceSets.main.get() }.toTypedArray())
+        executionData.setFrom("$buildDir/jacoco/jvmTest.exec")
+        classDirectories.setFrom(
+            files(
+                subprojects
+                    .map {
+                        it.buildDir.resolve("classes/kotlin/jvm/main")
+                    }
+                    .flatMap { it.walkBottomUp().toList() }
+            )
+        )
+        sourceDirectories.setFrom(
+            files(
+                subprojects.flatMap {
+                    listOf(
+                        it.projectDir.resolve("src/commonMain"),
+                        it.projectDir.resolve("src/jvmMain")
+                    ).filter(File::exists)
+                }
+            )
+        )
 
         reports {
             html.isEnabled = true
             xml.isEnabled = true
         }
     }
+
+    val detektAll by registering {
+        allprojects {
+            this@registering.dependsOn(tasks.withType<io.gitlab.arturbosch.detekt.Detekt>())
+        }
+
+        getByName("check").dependsOn(this)
+    }
 }

config/detekt/detekt.yml

@@ -543,6 +543,7 @@ style:
     excludedFunctions: 'describeContents'
     excludeAnnotatedFunction: ['dagger.Provides']
   LibraryCodeMustSpecifyReturnType:
+    excludes: [ '**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**' ]
     active: true
   LibraryEntitiesShouldNotBePublic:
     active: false

ksp/build.gradle.kts

@@ -1,15 +1,44 @@
 plugins {
+    kotlin("multiplatform")
+    `java-library`
     kotlin("kapt")
+    id("io.gitlab.arturbosch.detekt")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+kotlin {
+    explicitApi()
+
+    jvm()
+
+    sourceSets {
+        val jvmMain by getting {
+            dependencies {
+                implementation(projects.runtime)
+                implementation(projects.processingCommon)
+                implementation(libs.squareUp.kotlinPoet)
+                compileOnly(libs.ksp.api)
+                implementation(libs.autoService.runtime)
+                configurations["kapt"].dependencies.add(project.dependencies.create(libs.autoService.processor.get()))
+            }
+        }
+    }
+}
+
+tasks {
+    withType<io.gitlab.arturbosch.detekt.Detekt> {
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+}
+
 dependencies {
-    implementation(projects.runtime)
-    implementation(projects.processingCommon)
-    implementation(libs.squareUp.kotlinPoet)
-    compileOnly(libs.ksp.api)
-    implementation(libs.autoService.runtime)
-    kapt(libs.autoService.processor)
+    detektPlugins(Dependencies.detektFormatting)
 }
 
 kapt {

processing-common/build.gradle.kts

@@ -1,8 +1,70 @@
 plugins {
+    kotlin("multiplatform")
+    `java-library`
+    jacoco
+    id("io.gitlab.arturbosch.detekt")
+    id("org.jetbrains.dokka")
     `maven-publish`
 }
 
+kotlin {
+    explicitApi()
+
+    jvm {
+        testRuns["test"].executionTask.configure {
+            useJUnitPlatform()
+        }
+    }
+
+    sourceSets {
+        val jvmMain by getting {
+            dependencies {
+                implementation(projects.runtime)
+                implementation(libs.squareUp.kotlinPoet)
+            }
+        }
+
+        val jvmTest by getting {
+            dependencies {
+                implementation(libs.junit.jupiter)
+            }
+        }
+    }
+}
+
+jacoco {
+    toolVersion = Versions.jacoco
+}
+
+tasks {
+    jacocoTestReport {
+        dependsOn("jvmTest")
+
+        executionData.setFrom("$buildDir/jacoco/jvmTest.exec")
+        classDirectories.setFrom(
+            File("$buildDir/classes/kotlin/jvm/main").walkBottomUp().toList()
+        )
+        sourceDirectories.setFrom(
+            files(
+                "src/commonMain",
+                "src/jvmMain"
+            )
+        )
+
+        reports {
+            html.isEnabled = true
+            xml.isEnabled = true
+        }
+    }
+
+    withType<io.gitlab.arturbosch.detekt.Detekt> {
+        jvmTarget = JavaVersion.VERSION_1_8.toString()
+    }
+}
+
 dependencies {
+    detektPlugins(Dependencies.detektFormatting)
+
     implementation(projects.runtime)
     implementation(libs.squareUp.kotlinPoet)
 

processing-common/src/main/kotlin/com/livefront/sealedenum/internal/common/spec/SealedEnumTypeSpec.kt → processing-common/src/jvmMain/kotlin/com/livefront/sealedenum/internal/common/spec/SealedEnumTypeSpec.kt

@@ -14,6 +14,7 @@ import com.squareup.kotlinpoet.TypeSpec
 import com.squareup.kotlinpoet.asClassName
 import com.squareup.kotlinpoet.buildCodeBlock
 import javax.lang.model.element.TypeElement
+import kotlin.reflect.KClass
 
 /**
  * A builder for a [SealedEnum] object for the given [sealedClass].
@@ -212,13 +213,13 @@ internal data class SealedEnumTypeSpec(
             .build()
 
     private fun createEnumClassGetter(enumForSealedEnum: ClassName): PropertySpec {
-        val parameterizedClass = Class::class.asClassName().parameterizedBy(enumForSealedEnum)
+        val parameterizedClass = KClass::class.asClassName().parameterizedBy(enumForSealedEnum)
 
         return PropertySpec.builder("enumClass", parameterizedClass)
             .addModifiers(KModifier.OVERRIDE)
             .getter(
                 FunSpec.getterBuilder()
-                    .addStatement("return %T::class.java", enumForSealedEnum)
+                    .addStatement("return %T::class", enumForSealedEnum)
                     .build()
             )
             .build()

processing-tests/common/test/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClass.kt → processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClass.kt

@@ -15,10 +15,10 @@ package com.livefront.sealedenum.compilation.basic
 import com.livefront.sealedenum.EnumForSealedEnumProvider
 import com.livefront.sealedenum.SealedEnum
 import com.livefront.sealedenum.SealedEnumWithEnumProvider
-import java.lang.Class
 import kotlin.Int
 import kotlin.String
 import kotlin.collections.List
+import kotlin.reflect.KClass
 
 /**
  * An isomorphic enum for the sealed class [EmptySealedClass]
@@ -46,8 +46,8 @@ public object EmptySealedClassSealedEnum : SealedEnum<EmptySealedClass>,
     public override val values: List<EmptySealedClass> = emptyList()
 
 
-    public override val enumClass: Class<EmptySealedClassEnum>
-        get() = EmptySealedClassEnum::class.java
+    public override val enumClass: KClass<EmptySealedClassEnum>
+        get() = EmptySealedClassEnum::class
 
     public override fun ordinalOf(obj: EmptySealedClass): Int = throw
             AssertionError("Constructing a EmptySealedClass is impossible, since it has no sealed subclasses")

processing-tests/common/test/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt → processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedClassTests.kt

@@ -23,7 +23,7 @@ class EmptySealedClassTests {
 
     @Test
     fun `correct enum class`() {
-        assertEquals(EmptySealedClassEnum::class.java, EmptySealedClass.sealedEnum.enumClass)
+        assertEquals(EmptySealedClassEnum::class, EmptySealedClass.sealedEnum.enumClass)
     }
 
     @Test

processing-tests/common/test/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterface.kt → processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterface.kt

@@ -15,10 +15,10 @@ package com.livefront.sealedenum.compilation.basic
 import com.livefront.sealedenum.EnumForSealedEnumProvider
 import com.livefront.sealedenum.SealedEnum
 import com.livefront.sealedenum.SealedEnumWithEnumProvider
-import java.lang.Class
 import kotlin.Int
 import kotlin.String
 import kotlin.collections.List
+import kotlin.reflect.KClass
 
 /**
  * An isomorphic enum for the sealed class [EmptySealedInterface]
@@ -46,8 +46,8 @@ public object EmptySealedInterfaceSealedEnum : SealedEnum<EmptySealedInterface>,
     public override val values: List<EmptySealedInterface> = emptyList()
 
 
-    public override val enumClass: Class<EmptySealedInterfaceEnum>
-        get() = EmptySealedInterfaceEnum::class.java
+    public override val enumClass: KClass<EmptySealedInterfaceEnum>
+        get() = EmptySealedInterfaceEnum::class
 
     public override fun ordinalOf(obj: EmptySealedInterface): Int = throw
             AssertionError("Constructing a EmptySealedInterface is impossible, since it has no sealed subclasses")

processing-tests/common/test/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt → processing-tests/common/src/jvmTest/kotlin/com/livefront/sealedenum/compilation/basic/EmptySealedInterfaceTests.kt

@@ -23,7 +23,7 @@ class EmptySealedInterfaceTests {
 
     @Test
     fun `correct enum class`() {
-        assertEquals(EmptySealedInterfaceEnum::class.java, EmptySealedInterface.sealedEnum.enumClass)
+        assertEquals(EmptySealedInterfaceEnum::class, EmptySealedInterface.sealedEnum.enumClass)
     }
 
     @Test