From 54b3de775d707c741268a62da294e97a2c371b4b Mon Sep 17 00:00:00 2001 From: Konstantin Tskhovrebov Date: Wed, 18 Aug 2021 15:02:43 +0300 Subject: [PATCH] Add K/N compiler args builders. --- .../tasks/KotlinNativeCompilerArgBuilder.kt | 183 ++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeCompilerArgBuilder.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeCompilerArgBuilder.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeCompilerArgBuilder.kt new file mode 100644 index 00000000000..837ee2ae3c0 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/tasks/KotlinNativeCompilerArgBuilder.kt @@ -0,0 +1,183 @@ +/* + * 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.targets.native.tasks + +import org.gradle.api.file.FileCollection +import org.gradle.api.file.FileTree +import org.jetbrains.kotlin.gradle.dsl.KotlinCommonToolOptions +import org.jetbrains.kotlin.gradle.plugin.mpp.BitcodeEmbeddingMode +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 java.io.File + +internal class CompilerPluginData( + val files: FileCollection, + val options: CompilerPluginOptions +) + +internal class SharedCompilationData( + val manifestFile: File, + val isAllowCommonizer: Boolean +) + +internal fun buildKotlinNativeKlibCompilerArgs( + outFile: File, + optimized: Boolean, + debuggable: Boolean, + target: KonanTarget, + libraries: List, + + languageSettings: LanguageSettings, + enableEndorsedLibs: Boolean, + kotlinOptions: KotlinCommonToolOptions, + compilerPlugins: List, + + moduleName: String, + shortModuleName: String, + friendModule: FileCollection, + sharedCompilationData: SharedCompilationData?, + source: FileTree, + commonSourcesTree: FileTree +): List = mutableListOf().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", moduleName) + add("-Xshort-module-name=$shortModuleName") + + val friends = friendModule.files + if (friends.isNotEmpty()) { + addArg("-friend-modules", friends.joinToString(File.pathSeparator) { it.absolutePath }) + } + + addAll(buildKotlinNativeCommonArgs(languageSettings, enableEndorsedLibs, kotlinOptions, compilerPlugins)) + + addAll(source.map { it.absolutePath }) + if (!commonSourcesTree.isEmpty) { + add("-Xcommon-sources=${commonSourcesTree.joinToString(separator = ",") { it.absolutePath }}") + } +} + +internal fun buildKotlinNativeBinaryLinkerArgs( + outFile: File, + optimized: Boolean, + debuggable: Boolean, + target: KonanTarget, + outputKind: CompilerOutputKind, + libraries: List, + + languageSettings: LanguageSettings, + enableEndorsedLibs: Boolean, + kotlinOptions: KotlinCommonToolOptions, + compilerPlugins: List, + + processTests: Boolean, + entryPoint: String?, + embedBitcode: BitcodeEmbeddingMode, + linkerOpts: List, + binaryOptions: Map, + isStaticFramework: Boolean, + exportLibraries: List, + includeLibraries: List, + additionalOptions: Collection +): List = mutableListOf().apply { + addAll(buildKotlinNativeMainArgs(outFile, optimized, debuggable, target, outputKind, libraries)) + addAll(additionalOptions) + + addKey("-tr", processTests) + addArgIfNotNull("-entry", entryPoint) + when (embedBitcode) { + BitcodeEmbeddingMode.MARKER -> add("-Xembed-bitcode-marker") + BitcodeEmbeddingMode.BITCODE -> add("-Xembed-bitcode") + else -> Unit + } + linkerOpts.forEach { addArg("-linker-option", it) } + binaryOptions.forEach { (name, value) -> add("-Xbinary=$name=$value") } + addKey("-Xstatic-framework", isStaticFramework) + + addAll(buildKotlinNativeCommonArgs(languageSettings, enableEndorsedLibs, kotlinOptions, compilerPlugins)) + + exportLibraries.forEach { add("-Xexport-library=${it.absolutePath}") } + includeLibraries.forEach { add("-Xinclude=${it.absolutePath}") } +} + +private fun buildKotlinNativeMainArgs( + outFile: File, + optimized: Boolean, + debuggable: Boolean, + target: KonanTarget, + outputKind: CompilerOutputKind, + libraries: List +): List = mutableListOf().apply { + addKey("-opt", optimized) + addKey("-g", debuggable) + addKey("-ea", debuggable) + addArg("-target", target.name) + addArg("-p", outputKind.name.toLowerCase()) + addArg("-o", outFile.absolutePath) + libraries.forEach { addArg("-l", it.absolutePath) } +} + +internal fun buildKotlinNativeCommonArgs( + languageSettings: LanguageSettings, + enableEndorsedLibs: Boolean, + kotlinOptions: KotlinCommonToolOptions, + compilerPlugins: List +): List = mutableListOf().apply { + add("-Xmulti-platform") + addKey("-no-endorsed-libs", !enableEndorsedLibs) + + compilerPlugins.forEach { plugin -> + plugin.files.map { it.canonicalPath }.sorted().forEach { add("-Xplugin=$it") } + addArgs("-P", plugin.options.arguments) + } + + with(languageSettings) { + addArgIfNotNull("-language-version", languageVersion) + addArgIfNotNull("-api-version", apiVersion) + addKey("-progressive", progressiveMode) + enabledLanguageFeatures.forEach { add("-XXLanguage:+$it") } + optInAnnotationsInUse.forEach { add("-opt-in=$it") } + } + + addKey("-Werror", kotlinOptions.allWarningsAsErrors) + addKey("-nowarn", kotlinOptions.suppressWarnings) + addKey("-verbose", kotlinOptions.verbose) + + addAll(kotlinOptions.freeCompilerArgs) +} + +private fun MutableList.addArg(parameter: String, value: String) { + add(parameter) + add(value) +} + +private fun MutableList.addArgs(parameter: String, values: Iterable) { + values.forEach { + addArg(parameter, it) + } +} + +private fun MutableList.addArgIfNotNull(parameter: String, value: String?) { + if (value != null) { + addArg(parameter, value) + } +} + +private fun MutableList.addKey(key: String, enabled: Boolean) { + if (enabled) { + add(key) + } +} \ No newline at end of file