[PL] Change semantics of CLI parameter -Xpartial-linkage

This parameter accepts the name of the "mode" in which the partial linkage would work. Currently, only two options are supported: 'enable', 'disable'. But the list may be extended in the future as needed.

At the moment the 'disable' option is the default one. This will be changed in #KT-51447, #KT-51443.

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JSCompilerArguments.kt

@@ -540,11 +540,11 @@ class K2JSCompilerArguments : CommonCompilerArguments() {
             field = if (value.isNullOrEmpty()) null else value
         }
 
-    @Argument(value = "-Xpartial-linkage", description = "Enable partial linkage mode")
-    var partialLinkage = false
+    @Argument(value = "-Xpartial-linkage", valueDescription = "{enable|disable}", description = "Use partial linkage mode")
+    var partialLinkageMode: String? = null
         set(value) {
             checkFrozen()
-            field = value
+            field = if (value.isNullOrEmpty()) null else value
         }
 
     @Argument(value = "-Xpartial-linkage-loglevel", valueDescription = "{info|warning|error}", description = "Partial linkage compile-time log level")

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt

@@ -424,8 +424,12 @@ class K2NativeCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xlazy-ir-for-caches", valueDescription = "{disable|enable}", description = "Use lazy IR for cached libraries")
     var lazyIrForCaches: String? = null
 
-    @Argument(value = "-Xpartial-linkage", description = "Enable partial linkage mode")
-    var partialLinkage: Boolean = false
+    @Argument(value = "-Xpartial-linkage", valueDescription = "{enable|disable}", description = "Use partial linkage mode")
+    var partialLinkageMode: String? = null
+        set(value) {
+            checkFrozen()
+            field = if (value.isNullOrEmpty()) null else value
+        }
 
     @Argument(value = "-Xpartial-linkage-loglevel", valueDescription = "{info|warning|error}", description = "Partial linkage compile-time log level")
     var partialLinkageLogLevel: String? = null

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

@@ -172,7 +172,10 @@ 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.partialLinkage, arguments.partialLinkageLogLevel)
+        configuration.setupPartialLinkageConfig(arguments.partialLinkageMode, arguments.partialLinkageLogLevel) { errorMessage ->
+            messageCollector.report(ERROR, errorMessage, null)
+            return COMPILATION_ERROR
+        }
 
         val commonSourcesArray = arguments.commonSources
         val commonSources = commonSourcesArray?.toSet() ?: emptySet()

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

@@ -8,33 +8,54 @@ package org.jetbrains.kotlin.ir.linkage.partial
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 
-data class PartialLinkageConfig(val isEnabled: Boolean, val logLevel: PartialLinkageLogLevel) {
+data class PartialLinkageConfig(val mode: PartialLinkageMode, val logLevel: PartialLinkageLogLevel) {
+    val isEnabled get() = mode.isEnabled
+
     companion object {
-        val DEFAULT = PartialLinkageConfig(false, PartialLinkageLogLevel.ERROR)
+        val DEFAULT = PartialLinkageConfig(PartialLinkageMode.DEFAULT, PartialLinkageLogLevel.ERROR)
 
         val KEY = CompilerConfigurationKey.create<PartialLinkageConfig>("partial linkage configuration")
     }
 }
 
+// In the future the set of supported modes can be extended.
+enum class PartialLinkageMode(val isEnabled: Boolean) {
+    ENABLE(isEnabled = true), DISABLE(isEnabled = false);
+
+    companion object {
+        val DEFAULT = DISABLE // TODO: should be changed to `ENABLE` (KT-51447, KT-51443)
+
+        fun resolveMode(key: String): PartialLinkageMode? =
+            values().firstOrNull { entry -> key == entry.name.lowercase() }
+    }
+}
+
 enum class PartialLinkageLogLevel {
     INFO, WARNING, ERROR;
 
     companion object {
         val DEFAULT = WARNING
 
-        fun resolveLogLevel(key: String): PartialLinkageLogLevel =
+        fun resolveLogLevel(key: String): PartialLinkageLogLevel? =
             values().firstOrNull { entry -> entry.name.equals(key, ignoreCase = true) }
-                ?: error("Unknown partial linkage compile-time log level '$key'")
     }
 }
 
 val CompilerConfiguration.partialLinkageConfig: PartialLinkageConfig
     get() = this[PartialLinkageConfig.KEY] ?: PartialLinkageConfig.DEFAULT
 
-fun CompilerConfiguration.setupPartialLinkageConfig(isEnabled: Boolean, logLevel: String?) {
-    setupPartialLinkageConfig(
-        PartialLinkageConfig(isEnabled, logLevel?.let(PartialLinkageLogLevel::resolveLogLevel) ?: PartialLinkageLogLevel.DEFAULT)
-    )
+inline fun CompilerConfiguration.setupPartialLinkageConfig(mode: String?, logLevel: String?, onError: (String) -> Unit) {
+    val resolvedMode = if (mode != null)
+        PartialLinkageMode.resolveMode(mode) ?: return onError("Unknown partial linkage mode '$mode'")
+    else
+        PartialLinkageMode.DEFAULT
+
+    val resolvedLogLevel = if (logLevel != null)
+        PartialLinkageLogLevel.resolveLogLevel(logLevel) ?: return onError("Unknown partial linkage compile-time log level '$logLevel'")
+    else
+        PartialLinkageLogLevel.DEFAULT
+
+    setupPartialLinkageConfig(PartialLinkageConfig(resolvedMode, resolvedLogLevel))
 }
 
 fun CompilerConfiguration.setupPartialLinkageConfig(config: PartialLinkageConfig) {

compiler/testData/cli/js/jsExtraHelp.out

@@ -40,9 +40,10 @@ where advanced options include:
   -Xir-safe-external-boolean-diagnostic={log|exception}
                              Enable runtime diagnostics when access safely to boolean in external declarations
   -Xmetadata-only            Generate *.meta.js and *.kjsm files only
-  -Xpartial-linkage          Enable partial linkage mode
   -Xpartial-linkage-loglevel={info|warning|error}
                              Partial linkage compile-time log level
+  -Xpartial-linkage={enable|disable}
+                             Use partial linkage mode
   -Xstrict-implicit-export-types Generate strict types for implicitly exported entities inside d.ts files. Available in IR backend only.
   -Xtyped-arrays             Translate primitive arrays to JS typed arrays
   -Xes-classes               Generated JavaScript will use ES2015 classes.

js/js.tests/test/org/jetbrains/kotlin/js/test/ir/AbstractJsPartialLinkageTestCase.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageConfig
 import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageLogLevel
+import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageMode
 import org.jetbrains.kotlin.ir.linkage.partial.setupPartialLinkageConfig
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
@@ -235,7 +236,7 @@ abstract class AbstractJsPartialLinkageTestCase(val compilerType: CompilerType)
 
     private fun buildBinaryAndRun(mainModuleKlibFile: File, allDependencies: Dependencies) {
         val configuration = createConfig(MAIN_MODULE_NAME)
-        configuration.setupPartialLinkageConfig(PartialLinkageConfig(isEnabled = true, logLevel = PartialLinkageLogLevel.WARNING))
+        configuration.setupPartialLinkageConfig(PartialLinkageConfig(PartialLinkageMode.ENABLE, PartialLinkageLogLevel.WARNING))
 
         val compilationOutputs = when (compilerType) {
             CompilerType.K1_NO_IC, CompilerType.K2_NO_IC -> buildBinaryNoIC(configuration, mainModuleKlibFile, allDependencies)

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

@@ -270,7 +270,9 @@ 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.partialLinkage, arguments.partialLinkageLogLevel)
+    setupPartialLinkageConfig(arguments.partialLinkageMode, arguments.partialLinkageLogLevel) { errorMessage ->
+        report(ERROR, errorMessage)
+    }
     put(OMIT_FRAMEWORK_BINARY, arguments.omitFrameworkBinary)
     putIfNotNull(COMPILE_FROM_BITCODE, parseCompileFromBitcode(arguments, this@setupFromArguments, outputKind))
     putIfNotNull(SERIALIZED_DEPENDENCIES, parseSerializedDependencies(arguments, this@setupFromArguments))

native/native.tests/tests/org/jetbrains/kotlin/konan/blackboxtest/AbstractNativePartialLinkageTest.kt

@@ -211,7 +211,7 @@ abstract class AbstractNativePartialLinkageTest : AbstractNativeSimpleTest() {
         )
 
         private val COMPILER_ARGS_FOR_STATIC_CACHE_AND_EXECUTABLE = TestCompilerArgs(
-            COMPILER_ARGS_FOR_KLIB.compilerArgs + "-Xpartial-linkage"
+            COMPILER_ARGS_FOR_KLIB.compilerArgs + "-Xpartial-linkage=enable"
         )
 
         private val DEFAULT_EXTRAS = WithTestRunnerExtras(TestRunnerType.DEFAULT)