[Gradle] Remove unused 'buildKotlinNativeKlibCompilerArgs' as it cannot satisfy correct sourceFileFiltering

^KT-58466 Verification Pending

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeCompilerArgBuilder.kt

@@ -6,101 +6,25 @@
 package org.jetbrains.kotlin.gradle.targets.native.tasks
 
 import org.gradle.api.file.FileCollection
-import org.gradle.api.file.FileTree
-import org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerToolOptions
-import org.jetbrains.kotlin.gradle.dsl.KotlinNativeCompilerOptions
-import org.jetbrains.kotlin.gradle.dsl.usesK2
 import org.jetbrains.kotlin.gradle.plugin.mpp.BitcodeEmbeddingMode
-import org.jetbrains.kotlin.gradle.tasks.*
-import org.jetbrains.kotlin.gradle.tasks.fragmentSourcesCompilerArgs
-import org.jetbrains.kotlin.gradle.tasks.fragmentsCompilerArgs
+import org.jetbrains.kotlin.gradle.tasks.CompilerPluginOptions
 import org.jetbrains.kotlin.konan.target.CompilerOutputKind
 import org.jetbrains.kotlin.konan.target.KonanTarget
-import org.jetbrains.kotlin.project.model.LanguageSettings
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import java.io.File
 
 internal class CompilerPluginData(
     val files: FileCollection,
-    val options: CompilerPluginOptions
+    val options: CompilerPluginOptions,
 )
 
 internal class SharedCompilationData(
     val manifestFile: File,
     val isAllowCommonizer: Boolean,
-    val refinesPaths: FileCollection
+    val refinesPaths: FileCollection,
 )
 
-@Suppress("UNUSED_PARAMETER")
-internal fun buildKotlinNativeKlibCompilerArgs(
-    outFile: File,
-    optimized: Boolean,
-    debuggable: Boolean,
-    target: KonanTarget,
-    libraries: List<File>,
-
-    languageSettings: LanguageSettings,
-    compilerOptions: KotlinNativeCompilerOptions,
-    compilerPlugins: List<CompilerPluginData>,
-
-    shortModuleName: String,
-    friendModule: FileCollection,
-    libraryVersion: String,
-    sharedCompilationData: SharedCompilationData?,
-    source: FileTree,
-    commonSourcesTree: FileTree,
-    k2MultiplatformCompilationData: K2MultiplatformStructure
-): List<String> = mutableListOf<String>().apply {
-    addAll(buildKotlinNativeMainArgs(outFile, optimized, debuggable, target, CompilerOutputKind.LIBRARY, libraries))
-
-    sharedCompilationData?.let {
-        add("-Xexpect-actual-linker")
-        add("-Xmetadata-klib")
-        addArg("-manifest", sharedCompilationData.manifestFile.absolutePath)
-        addKey("-no-default-libs", sharedCompilationData.isAllowCommonizer)
-    }
-
-    // Configure FQ module name to avoid cyclic dependencies in klib manifests (see KT-36721).
-    addArg("-module-name", compilerOptions.moduleName.get())
-    add("-Xshort-module-name=$shortModuleName")
-
-    val friends = friendModule.files
-    if (friends.isNotEmpty()) {
-        addArg("-friend-modules", friends.joinToString(File.pathSeparator) { it.absolutePath })
-    }
-
-    // TODO: uncomment after advancing bootstrap.
-    //add("-library-version=libraryVersion")
-
-    if (sharedCompilationData != null) {
-        val refinesPaths = sharedCompilationData.refinesPaths.files
-        if (refinesPaths.isNotEmpty()) {
-            add("-Xrefines-paths=${refinesPaths.joinToString(separator = ",") { it.absolutePath }}")
-        }
-    }
-
-    if (compilerOptions.usesK2.get()) {
-        /*
-        For now, we only pass multiplatform structure to K2 for platform compilations
-        Metadata compilations will compile against pre-compiled klibs from their dependsOn
-        */
-        if (sharedCompilationData == null) {
-            add("-Xfragments=${k2MultiplatformCompilationData.fragmentsCompilerArgs.joinToString(",")}")
-            add("-Xfragment-sources=${k2MultiplatformCompilationData.fragmentSourcesCompilerArgs().joinToString(",")}")
-            add("-Xfragment-refines=${k2MultiplatformCompilationData.fragmentRefinesCompilerArgs.joinToString(",")}")
-        }
-    }
-
-    addAll(buildKotlinNativeCompileCommonArgs(languageSettings, compilerOptions, compilerPlugins))
-
-    addAll(source.map { it.absolutePath })
-
-    if (!compilerOptions.usesK2.get() && !commonSourcesTree.isEmpty) {
-        add("-Xcommon-sources=${commonSourcesTree.joinToString(separator = ",") { it.absolutePath }}")
-    }
-}
-
 internal fun buildKotlinNativeBinaryLinkerArgs(
     outFile: File,
     optimized: Boolean,
@@ -121,7 +45,7 @@ internal fun buildKotlinNativeBinaryLinkerArgs(
     isStaticFramework: Boolean,
     exportLibraries: List<File>,
     includeLibraries: List<File>,
-    additionalOptions: Collection<String>
+    additionalOptions: Collection<String>,
 ): List<String> = mutableListOf<String>().apply {
     addAll(buildKotlinNativeMainArgs(outFile, optimized, debuggable, target, outputKind, libraries))
     addAll(additionalOptions)
@@ -153,7 +77,7 @@ private fun buildKotlinNativeMainArgs(
     debuggable: Boolean,
     target: KonanTarget,
     outputKind: CompilerOutputKind,
-    libraries: List<File>
+    libraries: List<File>,
 ): List<String> = mutableListOf<String>().apply {
     addKey("-opt", optimized)
     addKey("-g", debuggable)
@@ -164,40 +88,9 @@ private fun buildKotlinNativeMainArgs(
     libraries.forEach { addArg("-l", it.absolutePath) }
 }
 
-internal fun buildKotlinNativeCompileCommonArgs(
-    languageSettings: LanguageSettings,
-    compilerOptions: KotlinCommonCompilerOptions,
-    compilerPlugins: List<CompilerPluginData>
-): List<String> = mutableListOf<String>().apply {
-    add("-Xmulti-platform")
-    addKey("-no-endorsed-libs", true)
-
-    compilerPlugins.forEach { plugin ->
-        plugin.files.map { it.canonicalPath }.sorted().forEach { add("-Xplugin=$it") }
-        addArgs("-P", plugin.options.arguments)
-    }
-
-    languageSettings.run {
-        enabledLanguageFeatures.forEach { add("-XXLanguage:+$it") }
-    }
-
-    addArgIfNotNull("-language-version", compilerOptions.languageVersion.orNull?.version)
-    addArgIfNotNull("-api-version", compilerOptions.apiVersion.orNull?.version)
-    addKey("-Werror", compilerOptions.allWarningsAsErrors.get())
-    addKey("-nowarn", compilerOptions.suppressWarnings.get())
-    addKey("-verbose", compilerOptions.verbose.get())
-    addKey("-progressive", compilerOptions.progressiveMode.get())
-    if (compilerOptions.useK2.get()) {
-        add("-Xuse-k2")
-    }
-    compilerOptions.optIn.get().forEach { add("-opt-in=$it") }
-
-    addAll(compilerOptions.freeCompilerArgs.get())
-}
-
-internal fun buildKotlinNativeCommonArgs(
+private fun buildKotlinNativeCommonArgs(
     toolOptions: KotlinCommonCompilerToolOptions,
-    compilerPlugins: List<CompilerPluginData>
+    compilerPlugins: List<CompilerPluginData>,
 ): List<String> = mutableListOf<String>().apply {
     add("-Xmulti-platform")
     addKey("-no-endorsed-libs", true)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeTasks.kt

@@ -503,29 +503,6 @@ internal constructor(
         return SharedCompilationData(manifestFile, isAllowCommonizer, refinesModule)
     }
 
-    internal fun buildCompilerArgs(isLenient: Boolean = false): List<String> = buildKotlinNativeKlibCompilerArgs(
-        outFile = outputFile.get(),
-        optimized = optimized,
-        debuggable = debuggable,
-        target = konanTarget,
-        libraries = runCatching { libraries.files.filterKlibsPassedToCompiler() }.getOrElse {
-            if (isLenient) emptyList() else throw it
-        },
-        languageSettings = languageSettings,
-        compilerOptions = compilerOptions,
-        compilerPlugins = listOfNotNull(
-            compilerPluginClasspath?.let { CompilerPluginData(it, compilerPluginOptions) },
-            kotlinPluginData?.orNull?.let { CompilerPluginData(it.classpath, it.options) }
-        ),
-        shortModuleName = shortModuleName,
-        friendModule = friendModule,
-        libraryVersion = artifactVersion,
-        sharedCompilationData = createSharedCompilationDataOrNull(),
-        source = sources.asFileTree,
-        commonSourcesTree = commonSourcesTree,
-        k2MultiplatformCompilationData = multiplatformStructure
-    )
-
     @TaskAction
     fun compile() {
         val output = outputFile.get()

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/compilerArgumetns/KotlinNativeCompileArgumentsTest.kt

@@ -8,12 +8,10 @@
 package org.jetbrains.kotlin.gradle.unitTests.compilerArgumetns
 
 import org.jetbrains.kotlin.cli.common.arguments.K2NativeCompilerArguments
-import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
 import org.jetbrains.kotlin.compilerRunner.ArgumentUtils
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
-import org.jetbrains.kotlin.gradle.idea.tcs.extras.sourcesClasspathKey
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilerArgumentsProducer.CreateCompilerArgumentsContext.Companion.default
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilerArgumentsProducer.CreateCompilerArgumentsContext.Companion.lenient
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
@@ -39,22 +37,23 @@ class KotlinNativeCompileArgumentsTest {
         run {
             val linuxX64MainCompilation = linuxX64Target.compilations.main
             val linuxX64MainCompileTask = linuxX64MainCompilation.compileTaskProvider.get()
-            `assert buildCompilerArgs and createCompilerArgs are equal`(linuxX64MainCompileTask)
+            `assert setupCompilerArgs and createCompilerArguments are equal`(linuxX64MainCompileTask)
         }
 
         /* Check commonMain compilation as 'shared native compilation' */
         run {
             val commonMainCompilation = kotlin.metadata().compilations.getByName("commonMain")
             val commonMainCompileTask = commonMainCompilation.compileTaskProvider.get() as KotlinNativeCompile
-            `assert buildCompilerArgs and createCompilerArgs are equal`(commonMainCompileTask)
+            `assert setupCompilerArgs and createCompilerArguments are equal`(commonMainCompileTask)
         }
     }
 
 
-    private fun `assert buildCompilerArgs and createCompilerArgs are equal`(compile: KotlinNativeCompile) {
+    private fun `assert setupCompilerArgs and createCompilerArguments are equal`(compile: KotlinNativeCompile) {
         val argumentsFromCompilerArgumentsProducer = compile.createCompilerArguments(lenient)
         val argumentsFromBuildCompilerArgs = K2NativeCompilerArguments().apply {
-            parseCommandLineArguments(compile.buildCompilerArgs(true), this)
+            @Suppress("DEPRECATION_ERROR")
+            compile.setupCompilerArgs(this, true)
         }
 
         assertEquals(