Merge remote-tracking branch 'origin/develop'

Author: fzhinkin

src/functionalTest/kotlin/kotlinx/validation/test/KlibVerificationTests.kt

@@ -852,7 +852,7 @@ internal class KlibVerificationTests : BaseKotlinGradleTest() {
     }
 
     @Test
-    fun `check cross compilation support`() {
+    fun `check cross compilation support for apiDump`() {
         Assume.assumeFalse(HostManager().isEnabled(KonanTarget.MACOS_ARM64))
 
         val runner = test {
@@ -868,7 +868,29 @@ internal class KlibVerificationTests : BaseKotlinGradleTest() {
                 arguments.addAll(listOf(":apiDump", "-Pkotlin.native.enableKlibsCrossCompilation=true"))
             }
         }
-
         checkKlibDump(runner.build(), "/examples/classes/TopLevelDeclarations.klib.all.dump")
     }
+
+    @Test
+    fun `check cross compilation support for apiCheck`() {
+        Assume.assumeFalse(HostManager().isEnabled(KonanTarget.MACOS_ARM64))
+
+        val runner = test {
+            settingsGradleKts {
+                resolve("/examples/gradle/settings/settings-name-testproject.gradle.kts")
+            }
+            buildGradleKts {
+                resolve("/examples/gradle/base/withNativePluginAndCrossCompilation.gradle.kts")
+            }
+            additionalBuildConfig("/examples/gradle/configuration/appleTargets/targets.gradle.kts")
+            addToSrcSet("/examples/classes/TopLevelDeclarations.kt")
+            abiFile(projectName = "testproject") {
+                resolve("/examples/classes/TopLevelDeclarations.klib.all.dump")
+            }
+            runner {
+                arguments.addAll(listOf(":apiCheck", "-Pkotlin.native.enableKlibsCrossCompilation=true"))
+            }
+        }
+        assertApiCheckPassed(runner.build())
+    }
 }

src/main/kotlin/BinaryCompatibilityValidatorPlugin.kt

@@ -494,6 +494,8 @@ private class KlibValidationPipelineBuilder(
             it.dumps.addAll(inferredDumps)
         }
 
+        val kgpVersion = readVersion()
+
         kotlin.targets.matching { it.emitsKlib }.configureEach { currentTarget ->
             val mainCompilation = currentTarget.mainCompilationOrNull ?: return@configureEach
 
@@ -502,7 +504,7 @@ private class KlibValidationPipelineBuilder(
             val targetConfig = TargetConfig(project, extension, targetName, intermediateFilesConfig)
             val apiBuildDir =
                 targetConfig.apiDir.flatMap { f -> project.layout.buildDirectory.asFile.map { it.resolve(f) } }
-            val targetSupported = targetIsSupported(currentTarget)
+            val targetSupported = targetIsSupported(currentTarget, kgpVersion)
             // If a target is supported, the workflow is simple: create a dump, then merge it along with other dumps.
             if (targetSupported) {
                 val buildTargetAbi = configureKlibCompilation(
@@ -542,32 +544,32 @@ private class KlibValidationPipelineBuilder(
         }
     }
 
-    private fun Project.targetIsSupported(target: KotlinTarget): Boolean {
+    private fun Project.targetIsSupported(target: KotlinTarget, kgpVersion: String?): Boolean {
         if (bannedTargets().contains(target.targetName)) return false
         if (target !is KotlinNativeTarget || HostManager().isEnabled(target.konanTarget)) {
             return true
         }
 
+        if (kgpVersion == null) return false
+
         // Starting from Kotlin 2.1.0, cross compilation could be enabled via property
-        if (!isKgpVersionAtLeast2_1(getKotlinPluginVersion())) return false
+        if (!isKgpVersionAtLeast2_1(kgpVersion)) return false
 
-        return (project.findProperty(ENABLE_CROSS_COMPILATION_PROPERTY_NAME) as String?).toBoolean()
+        val propertyValue = project.findProperty(ENABLE_CROSS_COMPILATION_PROPERTY_NAME) as String?
+        if (propertyValue == null) {
+            // Starting from Kotlin 2.2.20, cross compilation is enabled by default (KT-76421)
+            if (isKgpVersionAtLeast2_2_20(kgpVersion)) return true
+        }
+        return propertyValue.toBoolean()
     }
 
     // Compilable targets not supported by the host compiler
     private fun Project.unsupportedTargets(): Provider<Set<KlibTarget>> {
-        val banned = bannedTargets() // for testing only
         return project.provider {
-            val hm = HostManager()
+            val kgpVersion = readVersion()
             project.kotlinMultiplatform.targets.matching { it.emitsKlib }
                 .asSequence()
-                .filter {
-                    if (it is KotlinNativeTarget) {
-                        !hm.isEnabled(it.konanTarget) || it.targetName in banned
-                    } else {
-                        false
-                    }
-                }
+                .filterNot { targetIsSupported(it, kgpVersion) }
                 .map { it.toKlibTarget() }
                 .toSet()
         }
@@ -775,10 +777,21 @@ private var Configuration.isCanBeDeclaredCompat: Boolean
         }
     }
 
-private fun isKgpVersionAtLeast2_1(kgpVersion: String): Boolean {
+internal fun isKgpVersionAtLeast2_1(kgpVersion: String): Boolean {
     val parts = kgpVersion.split('.')
     if (parts.size < 2) return false
     val major = parts[0].toIntOrNull() ?: return false
     val minor = parts[1].toIntOrNull() ?: return false
     return major > 2 || (major == 2 && minor >= 1)
 }
+
+internal fun isKgpVersionAtLeast2_2_20(kgpVersion: String): Boolean {
+    val parts = kgpVersion.split('.')
+    if (parts.size < 3) return false
+    val major = parts[0].toIntOrNull() ?: return false
+    val minor = parts[1].toIntOrNull() ?: return false
+    if (major > 2 || (major == 2 && minor > 2)) return true
+
+    val patch = parts[2].split('-')[0].toIntOrNull() ?: return false
+    return major == 2 && minor == 2 && patch >= 20
+}

src/test/kotlin/tests/KgpVersionParsingTest.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2016-2025 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package tests
+
+import kotlinx.validation.*
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class KgpVersionParsingTest {
+    @Test
+    fun isKgpVersionAtLeast2_1() {
+        assertFalse(isKgpVersionAtLeast2_1(""))
+        assertFalse(isKgpVersionAtLeast2_1("3"))
+        assertFalse(isKgpVersionAtLeast2_1("1.9.20"))
+        assertTrue(isKgpVersionAtLeast2_1("2.1"))
+        assertTrue(isKgpVersionAtLeast2_1("2.1.0"))
+        assertTrue(isKgpVersionAtLeast2_1("2.2.0-RC3"))
+        assertTrue(isKgpVersionAtLeast2_1("2.2.20"))
+    }
+
+    @Test
+    fun isKgpVersionAtLeast2_2_20() {
+        assertFalse(isKgpVersionAtLeast2_2_20(""))
+        assertFalse(isKgpVersionAtLeast2_2_20("3"))
+        assertFalse(isKgpVersionAtLeast2_2_20("1.9.20"))
+        assertFalse(isKgpVersionAtLeast2_2_20("2.1"))
+        assertFalse(isKgpVersionAtLeast2_2_20("2.1.0"))
+        assertFalse(isKgpVersionAtLeast2_2_20("2.2.0-RC3"))
+        assertTrue(isKgpVersionAtLeast2_2_20("2.2.20"))
+        assertTrue(isKgpVersionAtLeast2_2_20("2.2.20-Beta2"))
+        assertTrue(isKgpVersionAtLeast2_2_20("2.2.21"))
+        assertTrue(isKgpVersionAtLeast2_2_20("2.3.0"))
+        assertTrue(isKgpVersionAtLeast2_2_20("3.0.0"))
+    }
+}