Migrate to kotlin-multiplatform plugin

Author: e5l

LICENSE

@@ -1,15 +1,33 @@
+
+
 plugins {
     id 'me.champeau.gradle.jmh' version '0.4.5'
 }
 
 apply plugin: 'kotlin-allopen'
 
+kotlin {
+    targets {
+        fromPreset(presets.jvmWithJava, 'jvmWithJava')
+    }
+}
 
 dependencies {
-    jmh project(':kotlinx-io-jvm')
-    jmh project(':kotlinx-io-jvm').sourceSets.test.output
-}
+    jmh rootProject
+    jmh rootProject.kotlin.targets.jvm.compilations.main.output.allOutputs
+    jmh rootProject.kotlin.targets.jvm.compilations.test.output.allOutputs
+    jmhCompile rootProject
+    jmhCompile rootProject.kotlin.targets.jvm.compilations.test.output.allOutputs
+
+    compile group: 'org.openjdk.jmh', name: 'jmh-core', version: '1.21'
 
+    jmhCompileClasspath rootProject
+    jmhCompileClasspath rootProject.kotlin.targets.jvm.compilations.main.output.allOutputs
+    jmhCompileClasspath rootProject.kotlin.targets.jvm.compilations.test.output.allOutputs
+    jmhRuntimeClasspath rootProject
+    jmhRuntimeClasspath rootProject.kotlin.targets.jvm.compilations.main.output.allOutputs
+    jmhRuntimeClasspath rootProject.kotlin.targets.jvm.compilations.test.output.allOutputs
+}
 allOpen {
     annotation('org.openjdk.jmh.annotations.State')
 }
@@ -19,7 +37,6 @@ jmh {
     jmhJar {
         archiveName = 'benchmarks.jar'
     }
-
 //    include = ['.*.myInput2?$', '.*.bufferInputStream']
 //    exclude = ['.*Guice.*', '.*PingPong.*']
 }

ReadMe.md

@@ -5,41 +5,47 @@
 configurations {
     testArtifacts
 }
+kotlin {
+    sourceSets {
+        jvmMain {
+            dependencies {
+                api "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+                api rootProject
+                api project(':kotlinx-coroutines-io')
+
+                api 'org.ow2.asm:asm-debug-all:5.2'
+                api 'com.google.code.gson:gson:2.6.2'
+            }
+        }
+        jvmTest {
+            dependencies {
+                api "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+                api "junit:junit:4.12"
+            }
+        }
+    }
+}
 
 dependencies {
-    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    compile project(":kotlinx-io-jvm")
-    compile 'org.ow2.asm:asm-debug-all:5.0.4'
-    compile 'com.google.code.gson:gson:2.6.2'
-
-    testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
-    testCompile "junit:junit:4.12"
-
-    testArtifacts project(':kotlinx-io-jvm')
-    testArtifacts project(':kotlinx-coroutines-io:kotlinx-coroutines-io-jvm')
+    testArtifacts rootProject
+    testArtifacts project(':kotlinx-coroutines-io')
 }
 
-sourceSets {
-    main {
-        kotlin {
-            srcDir 'src'
-        }
-    }
-    test {
-        kotlin {
-            srcDir 'test'
-        }
+jvmTest {
+    dependencies {
     }
-}
 
-test {
-    dependsOn cleanCompileTestKotlin
-    dependsOn configurations.testArtifacts
+    def modules = configurations.testArtifacts.dependencies.findAll { it instanceof ProjectDependency }.collect {
+        it.dependencyProject.projectDir
+    }
 
-    def modules = configurations.testArtifacts.dependencies.findAll { it instanceof ProjectDependency }.collect { it.dependencyProject.projectDir }
+    def artifactNames = configurations.testArtifacts.dependencies.findAll { it instanceof ProjectDependency }.collect {
+        it.dependencyProject.name
+    }
 
     systemProperty 'validator.input.modules', modules.join(File.pathSeparator)
+    systemProperty 'validator.input.artifactNames', artifactNames.join(File.pathSeparator)
     systemProperty 'overwrite.output', project.properties['overwrite.output']
     jvmArgs '-ea'
 }

benchmarks/build.gradle

@@ -32,28 +32,29 @@ fun getBinaryAPI(
             val classAccess = AccessFlags(effectiveAccess and Opcodes.ACC_STATIC.inv())
             val supertypes = listOf(superName) - "java/lang/Object" + interfaces.sorted()
 
-            val memberSignatures = (
-                fields.map {
-                    with(it) {
-                        FieldBinarySignature(
-                            name,
-                            desc,
-                            isPublishedApi(),
-                            AccessFlags(access)
-                        )
-                    }
-                } +
-                    methods.map {
-                        with(it) {
-                            MethodBinarySignature(
-                                name,
-                                desc,
-                                isPublishedApi(),
-                                AccessFlags(access)
-                            )
-                        }
-                    }
-                ).filter {
+            val fieldSignatures = fields.map {
+                with(it) {
+                    FieldBinarySignature(
+                        name,
+                        desc,
+                        isPublishedApi(),
+                        AccessFlags(access)
+                    )
+                }
+            }
+
+            val methodSignatures = methods.map {
+                with(it) {
+                    MethodBinarySignature(
+                        name,
+                        desc,
+                        isPublishedApi(),
+                        AccessFlags(access)
+                    )
+                }
+            }
+
+            val memberSignatures = (fieldSignatures + methodSignatures).filter {
                 it.isEffectivelyPublic(classAccess, classVisibility)
             }
 

benchmarks/src/jmh/kotlin/kotlinx/io/tests/benchmarks/PacketReadBenchmark.kt

@@ -111,7 +111,7 @@ data class AccessFlags(val access: Int) {
     val isSynthetic: Boolean get() = isSynthetic(access)
 
     fun getModifiers(): List<String> =
-        ACCESS_NAMES.entries.mapNotNull { if (access and it.key != 0) it.value else null }
+        ACCESS_NAMES.entries.filter { access and it.key != 0 }.map { it.value }
 
     fun getModifierString(): String = getModifiers().joinToString(" ")
 }
@@ -123,8 +123,7 @@ fun isFinal(access: Int) = access and Opcodes.ACC_FINAL != 0
 fun isSynthetic(access: Int) = access and Opcodes.ACC_SYNTHETIC != 0
 
 
-fun ClassNode.isEffectivelyPublic(classVisibility: ClassVisibility?) =
-    isPublic(access)
+fun ClassNode.isEffectivelyPublic(classVisibility: ClassVisibility?) = isPublic(access)
         && !isLocal()
         && !isWhenMappings()
         && (classVisibility?.isPublic(isPublishedApi()) ?: true)

benchmarks/src/jmh/kotlin/kotlinx/io/tests/benchmarks/TextDecodeBenchmark.kt

@@ -36,6 +36,8 @@ fun ClassVisibility.findSetterForProperty(property: MemberVisibility): MemberVis
 }
 
 fun readKotlinVisibilities(declarationFile: File): Map<String, ClassVisibility> {
+    check(declarationFile.exists())
+
     val result = mutableListOf<ClassVisibility>()
     declarationFile.bufferedReader().use { reader ->
         val jsonReader = JsonReader(reader)

binary-compatibility-validator/build.gradle

@@ -17,15 +17,18 @@ class PublicApiTest(
 ) {
     companion object {
         private val modulesList = System.getProperty("validator.input.modules")
+        private val artifactNamesList = System.getProperty("validator.input.artifactNames")
         private val nonPublicPackages: List<String> = emptyList()
 
         @Parameterized.Parameters(name = "{1}")
         @JvmStatic
         fun modules(): List<Array<Any>> {
-            return modulesList.split(File.pathSeparator).map { path ->
-                val dir = File(path)
-                arrayOf<Any>(dir, dir.name)
-            }
+            val names = artifactNamesList.split(File.pathSeparator)
+            return modulesList
+                .split(File.pathSeparator)
+                .map { path -> File(path) }
+                .zip(names)
+                .map { it.toList().toTypedArray() }
         }
     }
 
@@ -39,11 +42,11 @@ class PublicApiTest(
                 .map { readKotlinVisibilities(it) }
                 .reduce { m1, m2 -> m1 + m2 }
         val api = getBinaryAPI(JarFile(jarFile), visibilities).filterOutNonPublic(nonPublicPackages)
-        api.dumpAndCompareWith(File("reference-public-api").resolve("$moduleName.txt"))
+        api.dumpAndCompareWith(File("reference-public-api").resolve("$moduleName-jvm.txt"))
     }
 
     private fun getJarPath(libsDir: File): File {
-        val regex = Regex("$moduleName-.+\\.jar")
+        val regex = Regex("$moduleName-jvm.+\\.jar")
         val files = (libsDir.listFiles() ?: throw Exception("Cannot list files in $libsDir"))
             .filter {
                 it.name.let {

binary-compatibility-validator/src/PublicApiDump.kt renamed to binary-compatibility-validator/jvm/src/PublicApiDump.kt

@@ -35,7 +35,7 @@ private fun assertEqualsToFile(to: File, actual: CharSequence) {
     assertEquals(
         expectedText,
         actualText,
-        "Actual data differs from file content: ${to.name}\nTo overwrite the expected API rerun with -Doverwrite.output=true parameter\n"
+        "Actual data differs from file content: ${to.name}\nTo overwrite the expected API rerun with -Poverwrite.output=true parameter\n"
     )
 }