[PL] Disallow partial linkage when compiler is configured to produce KLIB

Partial linkage is intended for producing binaries, not libraries.

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -172,10 +172,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         configuration.put(JSConfigurationKeys.WASM_ENABLE_ARRAY_RANGE_CHECKS, arguments.wasmEnableArrayRangeChecks)
         configuration.put(JSConfigurationKeys.WASM_ENABLE_ASSERTS, arguments.wasmEnableAsserts)
         configuration.put(JSConfigurationKeys.WASM_GENERATE_WAT, arguments.wasmGenerateWat)
-        configuration.setupPartialLinkageConfig(arguments.partialLinkageMode, arguments.partialLinkageLogLevel) { errorMessage ->
-            messageCollector.report(ERROR, errorMessage, null)
-            return COMPILATION_ERROR
-        }
 
         val commonSourcesArray = arguments.commonSources
         val commonSources = commonSourcesArray?.toSet() ?: emptySet()
@@ -262,6 +258,14 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
             mainCallArguments = mainCallArguments
         )
 
+        configuration.setupPartialLinkageConfig(
+            mode = arguments.partialLinkageMode,
+            logLevel = arguments.partialLinkageLogLevel,
+            compilerModeAllowsUsingPartialLinkage = arguments.includes != null, // Don't run PL when producing KLIB.
+            onWarning = { messageCollector.report(WARNING, it) },
+            onError = { messageCollector.report(ERROR, it) }
+        )
+
         // Run analysis if main module is sources
         var sourceModule: ModulesStructure? = null
         val includes = arguments.includes

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/linkage/partial/PartialLinkageConfig.kt

@@ -44,11 +44,25 @@ enum class PartialLinkageLogLevel {
 val CompilerConfiguration.partialLinkageConfig: PartialLinkageConfig
     get() = this[PartialLinkageConfig.KEY] ?: PartialLinkageConfig.DEFAULT
 
-inline fun CompilerConfiguration.setupPartialLinkageConfig(mode: String?, logLevel: String?, onError: (String) -> Unit) {
+fun CompilerConfiguration.setupPartialLinkageConfig(
-    val resolvedMode = if (mode != null)
+    mode: String?,
-        PartialLinkageMode.resolveMode(mode) ?: return onError("Unknown partial linkage mode '$mode'")
+    logLevel: String?,
-    else
+    compilerModeAllowsUsingPartialLinkage: Boolean,
-        PartialLinkageMode.DEFAULT
+    onWarning: (String) -> Unit,
+    onError: (String) -> Unit
+) {
+    val resolvedMode = when {
+        mode != null -> {
+            val resolvedMode = PartialLinkageMode.resolveMode(mode) ?: return onError("Unknown partial linkage mode '$mode'")
+            if (!compilerModeAllowsUsingPartialLinkage && resolvedMode.isEnabled) {
+                onWarning("Current compiler configuration does not allow using partial linkage mode '$mode'. The partial linkage will be disabled.")
+                PartialLinkageMode.DISABLE
+            } else
+                resolvedMode
+        }
+        !compilerModeAllowsUsingPartialLinkage -> PartialLinkageMode.DISABLE
+        else -> PartialLinkageMode.DEFAULT
+    }
 
     val resolvedLogLevel = if (logLevel != null)
         PartialLinkageLogLevel.resolveLogLevel(logLevel) ?: return onError("Unknown partial linkage compile-time log level '$logLevel'")

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/SetupConfiguration.kt

@@ -270,9 +270,15 @@ fun CompilerConfiguration.setupFromArguments(arguments: K2NativeCompilerArgument
     putIfNotNull(RUNTIME_LOGS, arguments.runtimeLogs)
     putIfNotNull(BUNDLE_ID, parseBundleId(arguments, outputKind, this@setupFromArguments))
     arguments.testDumpOutputPath?.let { put(TEST_DUMP_OUTPUT_PATH, it) }
-    setupPartialLinkageConfig(arguments.partialLinkageMode, arguments.partialLinkageLogLevel) { errorMessage ->
+
-        report(ERROR, errorMessage)
+    setupPartialLinkageConfig(
-    }
+            mode = arguments.partialLinkageMode,
+            logLevel = arguments.partialLinkageLogLevel,
+            compilerModeAllowsUsingPartialLinkage = outputKind != CompilerOutputKind.LIBRARY, // Don't run PL when producing KLIB.
+            onWarning = { report(WARNING, it) },
+            onError = { report(ERROR, it) }
+    )
+
     put(OMIT_FRAMEWORK_BINARY, arguments.omitFrameworkBinary)
     putIfNotNull(COMPILE_FROM_BITCODE, parseCompileFromBitcode(arguments, this@setupFromArguments, outputKind))
     putIfNotNull(SERIALIZED_DEPENDENCIES, parseSerializedDependencies(arguments, this@setupFromArguments))