[Args] Allow disabling language features by Xklib-ir-inliner argument

The `Xklib-ir-inliner` argument is intended not only for enabling
IR inliner-related language features while they are experimental
(i.e. `sinceVersion = null`), but also for disabling language features
when they will become mature (i.e. `sinceVersion != null`).

Author: ddolovov

compiler/arguments/resources/kotlin-compiler-arguments.json

@@ -784,6 +784,15 @@
                         "deprecatedVersion": null,
                         "removedVersion": null
                     }
+                },
+                {
+                    "name": "default",
+                    "releaseVersionsMetadata": {
+                        "introducedVersion": "2.3.0",
+                        "stabilizedVersion": null,
+                        "deprecatedVersion": null,
+                        "removedVersion": null
+                    }
                 }
             ]
         }
@@ -6398,7 +6407,7 @@
                                 "shortName": null,
                                 "deprecatedName": null,
                                 "description": {
-                                    "current": "Enable experimental IR inliner during KLIB generation.",
+                                    "current": "Set the mode of the experimental IR inliner on the first compilation stage.\n- `intra-module` mode enforces inlining of the functions only from the compiled module\n- `full` mode enforces inlining of all functions (from the compiled module and from all dependencies)\n   Warning: This mode will trigger setting the `pre-release` flag for the compiled library.\n- `disabled` mode completely disables the IR inliner\n- `default` mode lets the IR inliner run in `intra-module`, `full` or `disabled` mode based on the current language version\n        ",
                                     "valueInVersions": []
                                 },
                                 "delimiter": null,
@@ -6409,12 +6418,12 @@
                                         "valueInVersions": []
                                     },
                                     "defaultValue": {
-                                        "current": "disabled",
+                                        "current": "default",
                                         "valueInVersions": []
                                     }
                                 },
                                 "valueDescription": {
-                                    "current": "{intra-module|full|disabled}",
+                                    "current": "{intra-module|full|disabled|default}",
                                     "valueInVersions": []
                                 },
                                 "releaseVersionsMetadata": {

compiler/arguments/src/org/jetbrains/kotlin/arguments/description/CommonKlibBasedCompilerArguments.kt

@@ -84,7 +84,13 @@ val actualCommonKlibBasedArguments by compilerArgumentsLevel(CompilerArgumentsLe
     compilerArgument {
         name = "Xklib-ir-inliner"
         compilerName = "irInlinerBeforeKlibSerialization"
-        description = "Enable experimental IR inliner during KLIB generation.".asReleaseDependent()
+        description = """Set the mode of the experimental IR inliner on the first compilation stage.
+- `intra-module` mode enforces inlining of the functions only from the compiled module
+- `full` mode enforces inlining of all functions (from the compiled module and from all dependencies)
+   Warning: This mode will trigger setting the `pre-release` flag for the compiled library.
+- `disabled` mode completely disables the IR inliner
+- `default` mode lets the IR inliner run in `intra-module`, `full` or `disabled` mode based on the current language version
+        """.asReleaseDependent()
         valueType = KlibIrInlinerModeType()
         valueDescription = ReleaseDependent(
             current = KlibIrInlinerMode.entries.joinToString(prefix = "{", separator = "|", postfix = "}") { it.modeState }

compiler/arguments/src/org/jetbrains/kotlin/arguments/dsl/types/KlibIrInlinerMode.kt

@@ -34,4 +34,10 @@ enum class KlibIrInlinerMode(
             introducedVersion = KotlinReleaseVersion.v2_3_0,
         ),
     ),
-}
+    default(
+        modeState = "default",
+        releaseVersionsMetadata = KotlinReleaseVersionLifecycle(
+            introducedVersion = KotlinReleaseVersion.v2_3_0,
+        ),
+    ),
+}

compiler/arguments/src/org/jetbrains/kotlin/arguments/dsl/types/KotlinArgumentValueType.kt

@@ -160,7 +160,7 @@ class ReturnValueCheckerModeType(
 @Serializable
 class KlibIrInlinerModeType(
     override val isNullable: ReleaseDependent<Boolean> = ReleaseDependent(false),
-    override val defaultValue: ReleaseDependent<KlibIrInlinerMode?> = ReleaseDependent(KlibIrInlinerMode.disabled),
+    override val defaultValue: ReleaseDependent<KlibIrInlinerMode?> = ReleaseDependent(KlibIrInlinerMode.default),
 ) : KotlinArgumentValueType<KlibIrInlinerMode> {
     override fun stringRepresentation(value: KlibIrInlinerMode?): String {
         return value?.modeState.valueOrNullStringLiteral

compiler/cli/cli-common/gen/org/jetbrains/kotlin/cli/common/arguments/CommonKlibBasedCompilerArguments.kt

@@ -74,10 +74,16 @@ abstract class CommonKlibBasedCompilerArguments : CommonCompilerArguments() {
 
     @Argument(
         value = "-Xklib-ir-inliner",
-        valueDescription = "{intra-module|full|disabled}",
-        description = "Enable experimental IR inliner during KLIB generation.",
+        valueDescription = "{intra-module|full|disabled|default}",
+        description = """Set the mode of the experimental IR inliner on the first compilation stage.
+- `intra-module` mode enforces inlining of the functions only from the compiled module
+- `full` mode enforces inlining of all functions (from the compiled module and from all dependencies)
+   Warning: This mode will trigger setting the `pre-release` flag for the compiled library.
+- `disabled` mode completely disables the IR inliner
+- `default` mode lets the IR inliner run in `intra-module`, `full` or `disabled` mode based on the current language version
+        """,
     )
-    var irInlinerBeforeKlibSerialization: String = "disabled"
+    var irInlinerBeforeKlibSerialization: String = "default"
         set(value) {
             checkFrozen()
             field = value

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

@@ -20,14 +20,21 @@ open class CommonKlibBasedCompilerArgumentsConfigurator : CommonCompilerArgument
 
         val klibIrInlinerMode = KlibIrInlinerMode.fromString(arguments.irInlinerBeforeKlibSerialization)
         when (klibIrInlinerMode) {
+            KlibIrInlinerMode.DEFAULT -> {
+                // Do nothing. Rely on the default language feature states.
+            }
             KlibIrInlinerMode.INTRA_MODULE -> {
                 map[LanguageFeature.IrIntraModuleInlinerBeforeKlibSerialization] = LanguageFeature.State.ENABLED
+                map[LanguageFeature.IrCrossModuleInlinerBeforeKlibSerialization] = LanguageFeature.State.DISABLED
             }
             KlibIrInlinerMode.FULL -> {
                 map[LanguageFeature.IrIntraModuleInlinerBeforeKlibSerialization] = LanguageFeature.State.ENABLED
                 map[LanguageFeature.IrCrossModuleInlinerBeforeKlibSerialization] = LanguageFeature.State.ENABLED
             }
-            KlibIrInlinerMode.DISABLED -> {}
+            KlibIrInlinerMode.DISABLED -> {
+                map[LanguageFeature.IrIntraModuleInlinerBeforeKlibSerialization] = LanguageFeature.State.DISABLED
+                map[LanguageFeature.IrCrossModuleInlinerBeforeKlibSerialization] = LanguageFeature.State.DISABLED
+            }
             null -> {
                 collector.report(
                     CompilerMessageSeverity.ERROR,

compiler/testData/cli/js/jsExtraHelp.out

@@ -74,8 +74,14 @@ where advanced options include:
                              Define the compile-time log level for partial linkage.
   -Xklib-duplicated-unique-name-strategy={deny|allow-all-with-warning|allow-first-with-warning}
                              Klib dependencies usage strategy when multiple KLIBs has same `unique_name` property value.
-  -Xklib-ir-inliner={intra-module|full|disabled}
-                             Enable experimental IR inliner during KLIB generation.
+  -Xklib-ir-inliner={intra-module|full|disabled|default}
+                             Set the mode of the experimental IR inliner on the first compilation stage.
+                             - `intra-module` mode enforces inlining of the functions only from the compiled module
+                             - `full` mode enforces inlining of all functions (from the compiled module and from all dependencies)
+                                Warning: This mode will trigger setting the `pre-release` flag for the compiled library.
+                             - `disabled` mode completely disables the IR inliner
+                             - `default` mode lets the IR inliner run in `intra-module`, `full` or `disabled` mode based on the current language version
+
   -Xklib-abi-version=<version> Specify the custom ABI version to be written in KLIB. This option is intended only for tests.
                              Warning: This option does not affect KLIB ABI. Neither allows it making a KLIB backward-compatible with older ABI versions.
                              The only observable effect is that a custom ABI version is written to KLIB manifest file.

compiler/util/src/org/jetbrains/kotlin/config/KlibIrInlinerMode.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.config
 
 enum class KlibIrInlinerMode(val state: String) {
+    DEFAULT("default"),
     DISABLED("disabled"),
     FULL("full"),
     INTRA_MODULE("intra-module");