Move native target definition by sdk and arch from Cocoapods to MPP plugin.

#KT-47653

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/AppleSdk.kt

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.plugin.mpp.apple
+
+import org.jetbrains.kotlin.konan.target.KonanTarget
+
+internal object AppleSdk {
+    fun defineNativeTargets(platform: String, archs: List<String>): List<KonanTarget> {
+        class UnknownArchitectureException(platform: String, arch: String) :
+            IllegalArgumentException("Architecture $arch is not supported for platform $platform")
+
+        val targets: MutableSet<KonanTarget> = mutableSetOf()
+
+        when (platform) {
+            "iphoneos" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "arm64", "arm64e" -> KonanTarget.IOS_ARM64
+                        "armv7", "armv7s" -> KonanTarget.IOS_ARM32
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            "iphonesimulator" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "arm64", "arm64e" -> KonanTarget.IOS_SIMULATOR_ARM64
+                        "x86_64" -> KonanTarget.IOS_X64
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            "watchos" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "armv7k" -> KonanTarget.WATCHOS_ARM32
+                        "arm64_32" -> KonanTarget.WATCHOS_ARM64
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            "watchsimulator" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "arm64", "arm64e" -> KonanTarget.WATCHOS_SIMULATOR_ARM64
+                        "i386" -> KonanTarget.WATCHOS_X86
+                        "x86_64" -> KonanTarget.WATCHOS_X64
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            "appletvos" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "arm64", "arm64e" -> KonanTarget.TVOS_ARM64
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            "appletvsimulator" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "arm64", "arm64e" -> KonanTarget.TVOS_SIMULATOR_ARM64
+                        "x86_64" -> KonanTarget.TVOS_X64
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            "macosx" -> {
+                targets.addAll(archs.map { arch ->
+                    when (arch) {
+                        "arm64" -> KonanTarget.MACOS_ARM64
+                        "x86_64" -> KonanTarget.MACOS_X64
+                        else -> throw UnknownArchitectureException(platform, arch)
+                    }
+                })
+            }
+            else -> throw IllegalArgumentException("Platform $platform is not supported")
+        }
+
+        return targets.toList()
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/AppleXcodeTasks.kt

@@ -37,24 +37,10 @@ private object XcodeEnvironment {
     val target: KonanTarget?
         get() {
             val sdk = System.getenv("SDK_NAME") ?: return null
-            val isForArm = System.getenv("NATIVE_ARCH")?.startsWith("arm") ?: false
+            val arch = System.getenv("NATIVE_ARCH") ?: return null
+            val nativeTargets = AppleSdk.defineNativeTargets(sdk, listOf(arch))
 
-            return if (isForArm) when {
+            return nativeTargets.firstOrNull()
-                sdk.startsWith("iphoneos") -> KonanTarget.IOS_ARM64
-                sdk.startsWith("iphonesimulator") -> KonanTarget.IOS_SIMULATOR_ARM64
-                sdk.startsWith("watchos") -> KonanTarget.WATCHOS_ARM64
-                sdk.startsWith("watchsimulator") -> KonanTarget.WATCHOS_SIMULATOR_ARM64
-                sdk.startsWith("appletvos") -> KonanTarget.TVOS_ARM64
-                sdk.startsWith("appletvsimulator") -> KonanTarget.TVOS_SIMULATOR_ARM64
-                sdk.startsWith("macosx") -> KonanTarget.MACOS_ARM64
-                else -> null
-            } else when {
-                sdk.startsWith("iphonesimulator") -> KonanTarget.IOS_X64
-                sdk.startsWith("watchsimulator") -> KonanTarget.WATCHOS_X64
-                sdk.startsWith("appletvsimulator") -> KonanTarget.TVOS_X64
-                sdk.startsWith("macosx") -> KonanTarget.MACOS_X64
-                else -> null
-            }
         }
 
     val frameworkSearchDir: File?

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/cocoapods/KotlinCocoapodsPlugin.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.gradle.plugin.cocoapods.KotlinCocoapodsPlugin.Compan
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
 import org.jetbrains.kotlin.gradle.plugin.mpp.TestExecutable
+import org.jetbrains.kotlin.gradle.plugin.mpp.apple.AppleSdk
 import org.jetbrains.kotlin.gradle.plugin.whenEvaluated
 import org.jetbrains.kotlin.gradle.targets.native.tasks.*
 import org.jetbrains.kotlin.gradle.tasks.*
@@ -246,7 +247,7 @@ open class KotlinCocoapodsPlugin : Plugin<Project> {
 
         val platform = platforms.first()
 
-        val nativeTargets = getNativeTargets(platform, archs)
+        val nativeTargets = AppleSdk.defineNativeTargets(platform, archs)
 
         check(nativeTargets.isNotEmpty()) { "Could not identify native targets for platform: '$platform' and architectures: '$archs'" }
 
@@ -269,85 +270,6 @@ open class KotlinCocoapodsPlugin : Plugin<Project> {
         }
     }
 
-    private fun getNativeTargets(platform: String, archs: List<String>): List<KonanTarget> {
-        class UnknownArchitectureException(platform: String, arch: String) :
-            IllegalArgumentException("Architecture $arch is not supported for platform $platform")
-
-        val targets: MutableSet<KonanTarget> = mutableSetOf()
-
-        when (platform) {
-
-            "iphoneos" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "arm64", "arm64e" -> IOS_ARM64
-                        "armv7", "armv7s" -> IOS_ARM32
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-            "iphonesimulator" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "arm64", "arm64e" -> IOS_SIMULATOR_ARM64
-                        "x86_64" -> IOS_X64
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-            "watchos" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "armv7k" -> WATCHOS_ARM32
-                        "arm64_32" -> WATCHOS_ARM64
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-            "watchsimulator" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "arm64", "arm64e" -> WATCHOS_SIMULATOR_ARM64
-                        "i386" -> WATCHOS_X86
-                        "x86_64" -> WATCHOS_X64
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-            "appletvos" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "arm64", "arm64e" -> TVOS_ARM64
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-            "appletvsimulator" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "arm64", "arm64e" -> TVOS_SIMULATOR_ARM64
-                        "x86_64" -> TVOS_X64
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-            "macosx" -> {
-                targets.addAll(archs.map { arch ->
-                    when (arch) {
-                        "arm64" -> MACOS_ARM64
-                        "x86_64" -> MACOS_X64
-                        else -> throw UnknownArchitectureException(platform, arch)
-                    }
-                })
-            }
-
-            else -> throw IllegalArgumentException("Platform $platform is not supported")
-        }
-
-        return targets.toList()
-    }
-
-
     private fun createInterops(
         project: Project,
         kotlinExtension: KotlinMultiplatformExtension,