Merge rr/kishmakov/KT-30056 into master

konan/utils/src/org/jetbrains/kotlin/konan/target/KonanTarget.kt

@@ -23,6 +23,7 @@ enum class Family(
 
 enum class Architecture(val bitness: Int) {
     X64(64),
+    X86(32),
     ARM64(64),
     ARM32(32),
     MIPS32(32),
@@ -38,6 +39,7 @@ sealed class KonanTarget(override val name: String, val family: Family, val arch
     object IOS_X64 : KonanTarget("ios_x64", Family.IOS, Architecture.X64)
     object LINUX_X64 : KonanTarget("linux_x64", Family.LINUX, Architecture.X64)
     object MINGW_X64 : KonanTarget("mingw_x64", Family.MINGW, Architecture.X64)
+    object MINGW_X86 : KonanTarget("mingw_x86", Family.MINGW, Architecture.X86)
     object MACOS_X64 : KonanTarget("macos_x64", Family.OSX, Architecture.X64)
     object LINUX_ARM32_HFP : KonanTarget("linux_arm32_hfp", Family.LINUX, Architecture.ARM32)
     object LINUX_MIPS32 : KonanTarget("linux_mips32", Family.LINUX, Architecture.MIPS32)
@@ -58,7 +60,7 @@ object PredefinedKonanTargets {
         ANDROID_ARM32, ANDROID_ARM64,
         IOS_ARM32, IOS_ARM64, IOS_X64,
         LINUX_X64, LINUX_ARM32_HFP, LINUX_MIPS32, LINUX_MIPSEL32,
-        MINGW_X64,
+        MINGW_X64, MINGW_X86,
         MACOS_X64,
         KonanTarget.WASM32
     )
@@ -188,13 +190,18 @@ open class HostManager(subtargetProvider: SubTargetProvider = NoSubTargets()) {
         ) + zephyrSubtargets,
         KonanTarget.MINGW_X64 to setOf(
             KonanTarget.MINGW_X64,
-            KonanTarget.WASM32
+            KonanTarget.WASM32,
+            KonanTarget.LINUX_X64,
+            KonanTarget.LINUX_ARM32_HFP,
+            KonanTarget.ANDROID_ARM32
         ) + zephyrSubtargets,
         KonanTarget.MACOS_X64 to setOf(
             KonanTarget.MACOS_X64,
             KonanTarget.IOS_ARM32,
             KonanTarget.IOS_ARM64,
             KonanTarget.IOS_X64,
+            KonanTarget.LINUX_X64,
+            KonanTarget.LINUX_ARM32_HFP,
             KonanTarget.ANDROID_ARM32,
             KonanTarget.ANDROID_ARM64,
             KonanTarget.WASM32

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/NewMultiplatformIT.kt

@@ -18,22 +18,44 @@ import org.jetbrains.kotlin.konan.target.CompilerOutputKind
 import org.jetbrains.kotlin.konan.target.HostManager
 import org.junit.Assert
 import org.junit.Test
+import java.lang.StringBuilder
 import java.util.jar.JarFile
 import java.util.zip.ZipFile
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
-class NewMultiplatformIT : BaseGradleIT() {
+data class NativeTargets(val current: String, val supported: List<String>, val unsupported: List<String>)
-    val gradleVersion = GradleVersionRequired.AtLeast("4.7")
 
-    val nativeHostTargetName = when {
+fun configure(): NativeTargets {
+    val all = listOf("linux64", "macos64", "mingw64", "wasm32")
+
+    val current = when {
         HostManager.hostIsMingw -> "mingw64"
         HostManager.hostIsLinux -> "linux64"
         HostManager.hostIsMac -> "macos64"
         else -> error("Unknown host")
     }
 
+    val unsupported = when {
+        HostManager.hostIsMingw -> listOf("macos64")
+        HostManager.hostIsLinux -> listOf("macos64", "mingw64")
+        HostManager.hostIsMac -> listOf("mingw64")
+        else -> error("Unknown host")
+    }
+
+    val supported = all.filter { !unsupported.contains(it) }
+
+    return NativeTargets(current, supported, unsupported)
+}
+
+class NewMultiplatformIT : BaseGradleIT() {
+    val gradleVersion = GradleVersionRequired.AtLeast("4.7")
+
+    val nativeHostTargetName = configure().current
+    val supportedNativeTargets = configure().supported
+    val unsupportedNativeTargets = configure().unsupported
+
     private fun Project.targetClassesDir(targetName: String, sourceSetName: String = "main") =
         classesDir(sourceSet = "$targetName/$sourceSetName")
 
@@ -615,19 +637,21 @@ class NewMultiplatformIT : BaseGradleIT() {
             projectDir.resolve("repo")
         }
 
+        val dependencies = buildString {
+            append("dependencies {\n")
+            append("    allJvmImplementation 'com.example:sample-lib-jvm6:1.0'\n")
+            append("    nodeJsMainImplementation 'com.example:sample-lib-nodejs:1.0'\n")
+            for (target in supportedNativeTargets) {
+                append("    ${target}MainImplementation 'com.example:sample-lib-$target:1.0'\n")
+            }
+            append("}")
+        }
+
         with(Project("sample-app", gradleVersion, "new-mpp-lib-and-app")) {
             setupWorkingDir()
             gradleBuildScript().modify {
-                it.replace("implementation 'com.example:sample-lib:1.0'", "implementation 'com.example:sample-lib-metadata:1.0'") + "\n" + """
+                it.replace("implementation 'com.example:sample-lib:1.0'", "implementation 'com.example:sample-lib-metadata:1.0'") +
-                    repositories { maven { url '${repoDir.toURI()}' } }
+                "\nrepositories { maven { url '${repoDir.toURI()}' } }\n\n" + dependencies
-
-                    dependencies {
-                        allJvmImplementation 'com.example:sample-lib-jvm6:1.0'
-                        nodeJsMainImplementation 'com.example:sample-lib-nodejs:1.0'
-                        wasm32MainImplementation 'com.example:sample-lib-wasm32:1.0'
-                        ${nativeHostTargetName}MainImplementation 'com.example:sample-lib-${nativeHostTargetName.toLowerCase()}:1.0'
-                    }
-                """.trimIndent()
             }
 
             build("assemble") {
@@ -639,12 +663,8 @@ class NewMultiplatformIT : BaseGradleIT() {
 
     @Test
     fun testPublishingOnlySupportedNativeTargets() = with(Project("sample-lib", gradleVersion, "new-mpp-lib-and-app")) {
-        val (publishedVariant, nonPublishedVariant) = when {
+        val publishedVariant = nativeHostTargetName
-            HostManager.hostIsMac -> "macos64" to "linux64"
+        val nonPublishedVariant = unsupportedNativeTargets[0]
-            HostManager.hostIsLinux -> "linux64" to "macos64"
-            HostManager.hostIsMingw -> "mingw64" to "linux64"
-            else -> error("Unknown host")
-        }
 
         build("publish") {
             assertSuccessful()
@@ -1092,9 +1112,13 @@ class NewMultiplatformIT : BaseGradleIT() {
             }
 
             val host = nativeHostTargetName
+
+            val libraryCinteropTask = ":projectLibrary:cinteropStdio${host.capitalize()}"
+            val libraryCompileTask = ":projectLibrary:compileKotlin${host.capitalize()}"
+
             build(":projectLibrary:build") {
                 assertSuccessful()
-                assertTasksExecuted(":projectLibrary:cinteropStdio${host.capitalize()}")
+                assertTasksExecuted(libraryCinteropTask)
                 assertTrue(output.contains("Project test"), "No test output found")
                 assertFileExists("projectLibrary/build/classes/kotlin/$host/main/projectLibrary-cinterop-stdio.klib")
             }
@@ -1116,18 +1140,12 @@ class NewMultiplatformIT : BaseGradleIT() {
             // Check that changing the compiler version in properties causes interop reprocessing and source recompilation.
             build(":projectLibrary:build") {
                 assertSuccessful()
-                assertTasksUpToDate(
+                assertTasksUpToDate(libraryCinteropTask, libraryCompileTask)
-                    ":projectLibrary:cinteropStdio${host.capitalize()}",
-                    ":projectLibrary:compileKotlin${host.capitalize()}"
-                )
             }
 
-            build(":projectLibrary:build", "-Porg.jetbrains.kotlin.native.version=0.9.2") {
+            build(libraryCinteropTask, libraryCompileTask, "-Porg.jetbrains.kotlin.native.version=1.1.0") {
                 assertSuccessful()
-                assertTasksExecuted(
+                assertTasksExecuted(libraryCinteropTask, libraryCompileTask)
-                    ":projectLibrary:cinteropStdio${host.capitalize()}",
-                    ":projectLibrary:compileKotlin${host.capitalize()}"
-                )
             }
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinTargetContainerWithPresetFunctions.kt

@@ -212,6 +212,21 @@ interface KotlinTargetContainerWithPresetFunctions : KotlinTargetsContainerWithP
     fun mingwX64(name: String, configure: Closure<*>) = mingwX64(name) { ConfigureUtil.configure(configure, this) }
     fun mingwX64(configure: Closure<*>) = mingwX64 { ConfigureUtil.configure(configure, this) }
 
+    fun mingwX86(
+        name: String = "mingwX86",
+        configure: KotlinNativeTarget.() -> Unit = { }
+    ): KotlinNativeTarget =
+        configureOrCreate(
+            name,
+            presets.getByName("mingwX86") as KotlinNativeTargetPreset,
+            configure
+        )
+
+    fun mingwX86() = mingwX86("mingwX86") { }
+    fun mingwX86(name: String) = mingwX86(name) { }
+    fun mingwX86(name: String, configure: Closure<*>) = mingwX86(name) { ConfigureUtil.configure(configure, this) }
+    fun mingwX86(configure: Closure<*>) = mingwX86 { ConfigureUtil.configure(configure, this) }
+
     fun macosX64(
         name: String = "macosX64",
         configure: KotlinNativeTarget.() -> Unit = { }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/KotlinNativeTasks.kt

@@ -518,7 +518,7 @@ open class CInteropProcess : DefaultTask() {
             }
 
             libraries.files.filterExternalKlibs(project).forEach { library ->
-                addArg("-l", library.absolutePath)
+                addArg("-library", library.absolutePath)
             }
 
             addArgs("-copt", allHeadersDirs.map { "-I${it.absolutePath}" })