JVM_IR: introduce modes for IR serialization

Instead of a Boolean flag -Xserialize-ir, use modes: none,inline,all.
In "inline" mode, only information needed to deserialize bodies of inline
functions is serialized.
In the "all" mode, all declarations are serialized completely.

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

@@ -488,9 +488,10 @@ default: `indy-with-constants` for JVM target 9 or greater, `inline` otherwise""
 
     @Argument(
         value = "-Xserialize-ir",
+        valueDescription = "{none|inline|all}",
         description = "Save IR to metadata (EXPERIMENTAL)"
     )
-    var serializeIr: Boolean by FreezableVar(false)
+    var serializeIr: String by FreezableVar("none")
 
     @Argument(
         value = "-Xvalidate-ir",

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt

@@ -255,7 +255,7 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr
     put(JVMConfigurationKeys.NO_RESET_JAR_TIMESTAMPS, arguments.noResetJarTimestamps)
     put(JVMConfigurationKeys.NO_UNIFIED_NULL_CHECKS, arguments.noUnifiedNullChecks)
 
-    put(JVMConfigurationKeys.SERIALIZE_IR, arguments.serializeIr)
+    put(JVMConfigurationKeys.SERIALIZE_IR, JvmSerializeIrMode.fromString(arguments.serializeIr))
 
     put(JVMConfigurationKeys.VALIDATE_IR, arguments.validateIr)
     put(JVMConfigurationKeys.VALIDATE_BYTECODE, arguments.validateBytecode)

compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java

@@ -145,8 +145,8 @@ public class JVMConfigurationKeys {
     public static final CompilerConfigurationKey<Boolean> NO_REFLECT =
             CompilerConfigurationKey.create("Don't automatically include kotlin-reflect.jar into the output if the output is a jar");
 
-    public static final CompilerConfigurationKey<Boolean> SERIALIZE_IR =
+    public static final CompilerConfigurationKey<JvmSerializeIrMode> SERIALIZE_IR =
-            CompilerConfigurationKey.create("Serialize IR to class metadata");
+            CompilerConfigurationKey.create("What functions to serialize as IR to class metadata");
 
     public static final CompilerConfigurationKey<Boolean> VALIDATE_IR =
             CompilerConfigurationKey.create("Validate IR");

compiler/config.jvm/src/org/jetbrains/kotlin/config/JvmSerializeIrMode.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.config
+
+enum class JvmSerializeIrMode(val description: String) {
+    NONE("none"),
+    INLINE("inline"),
+    ALL("all");
+
+    companion object {
+        @JvmStatic
+        fun fromStringOrNull(string: String) = values().find { it.description == string }
+
+        @JvmStatic
+        fun fromString(string: String) = fromStringOrNull(string) ?: NONE
+    }
+}

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.backend.jvm.serialization.deserializeClassFromByteAr
 import org.jetbrains.kotlin.backend.jvm.serialization.deserializeIrFileFromByteArray
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations
@@ -69,7 +70,7 @@ open class JvmGeneratorExtensionsImpl(
 ) : GeneratorExtensions(), JvmGeneratorExtensions {
     override val classNameOverride: MutableMap<IrClass, JvmClassName> = mutableMapOf()
 
-    override val irDeserializationEnabled: Boolean = configuration.getBoolean(JVMConfigurationKeys.SERIALIZE_IR)
+    override val irDeserializationEnabled: Boolean = configuration.get(JVMConfigurationKeys.SERIALIZE_IR) != JvmSerializeIrMode.NONE
 
     override val cachedFields = CachedFieldsForObjectInstances(IrFactoryImpl, configuration.languageVersionSettings)
 

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
@@ -209,7 +210,9 @@ open class JvmIrCodegenFactory(
     override fun generateModule(state: GenerationState, input: CodegenFactory.BackendInput) {
         val (irModuleFragment, symbolTable, customPhaseConfig, irProviders, extensions, backendExtension, notifyCodegenStart) =
             input as JvmIrBackendInput
-        val irSerializer = if (state.configuration.getBoolean(JVMConfigurationKeys.SERIALIZE_IR))
+        val irSerializer = if (
+            state.configuration.get(JVMConfigurationKeys.SERIALIZE_IR, JvmSerializeIrMode.NONE) != JvmSerializeIrMode.NONE
+        )
             JvmIrSerializerImpl(state.configuration)
         else null
         val phaseConfig = customPhaseConfig ?: PhaseConfig(jvmPhases)

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrSerializerImpl.kt

@@ -9,6 +9,8 @@ import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.jvm.serialization.JvmGlobalDeclarationTable
 import org.jetbrains.kotlin.backend.jvm.serialization.JvmIrSerializerSession
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
@@ -31,5 +33,6 @@ class JvmIrSerializerImpl(private val configuration: CompilerConfiguration) : Jv
             configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None,
             declarationTable,
             mutableMapOf(),
+            configuration.get(JVMConfigurationKeys.SERIALIZE_IR) ?: JvmSerializeIrMode.NONE
         )
 }

compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIrSerializerSession.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IrFileSerializer
 import org.jetbrains.kotlin.backend.jvm.serialization.proto.JvmIr
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
@@ -20,11 +21,16 @@ class JvmIrSerializerSession(
     messageLogger: IrMessageLogger,
     private val declarationTable: DeclarationTable,
     expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>,
-    externallyVisibleOnly: Boolean = true,
+    mode: JvmSerializeIrMode,
     skipExpects: Boolean = false,
 ) : IrFileSerializer(
-    messageLogger, declarationTable, expectDescriptorToSymbol, CompatibilityMode.CURRENT, externallyVisibleOnly, skipExpects
+    messageLogger, declarationTable, expectDescriptorToSymbol, CompatibilityMode.CURRENT,
+    bodiesOnlyForInlines = mode == JvmSerializeIrMode.INLINE,
+    skipExpects
 ) {
+    init {
+        assert(mode != JvmSerializeIrMode.NONE)
+    }
 
     // Usage protocol: construct an instance, call only one of `serializeIrFile()` and `serializeTopLevelClass()` only once.
 

compiler/testData/cli/jvm/extraHelp.out

@@ -107,7 +107,8 @@ where advanced options include:
                              problems with parentheses in identifiers on certain platforms
   -Xscript-resolver-environment=<key=value[,]>
                              Script resolver environment in key-value pairs (the value could be quoted and escaped)
-  -Xserialize-ir             Save IR to metadata (EXPERIMENTAL)
+  -Xserialize-ir={none|inline|all}
+                             Save IR to metadata (EXPERIMENTAL)
   -Xsingle-module            Combine modules for source files and binary dependencies into a single module
   -Xskip-runtime-version-check Allow Kotlin runtime libraries of incompatible versions in the classpath
   -Xgenerate-strict-metadata-version

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JvmEnvironmentConfigurationDirectives.kt

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.test.directives
 
-import org.jetbrains.kotlin.config.JVMAssertionsMode
+import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.config.JvmClosureGenerationScheme
-import org.jetbrains.kotlin.config.JvmStringConcat
-import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.test.TestJavacVersion
 import org.jetbrains.kotlin.test.TestJdkKind
 import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability
@@ -86,7 +83,8 @@ object JvmEnvironmentConfigurationDirectives : SimpleDirectivesContainer() {
         description = "Enable old mangling scheme for inline classes"
     )
 
-    val SERIALIZE_IR by directive(
+    val SERIALIZE_IR by enumDirective(
-        description = "Enable serialization of JVM IR"
+        description = "Enable serialization of JVM IR",
+        additionalParser = JvmSerializeIrMode.Companion::fromString
     )
 }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/codegen/AbstractCompileKotlinAgainstInlineKotlinTest.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.test.runners.codegen
 
+import org.jetbrains.kotlin.config.JvmSerializeIrMode
 import org.jetbrains.kotlin.test.Constructor
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
@@ -74,7 +75,7 @@ open class AbstractIrSerializeCompileKotlinAgainstInlineKotlinTest : AbstractIrC
         super.configure(builder)
         builder.apply {
             defaultDirectives {
-                +SERIALIZE_IR
+                SERIALIZE_IR.with(JvmSerializeIrMode.INLINE)
             }
 
             configureIrHandlersStep {

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/AnalysisFlagExtractor.kt

@@ -39,6 +39,11 @@ private val patterns = buildList {
         "USE_OLD_INLINE_CLASSES_MANGLING_SCHEME",
         JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME,
     )
+    createPattern(
+        "SERIALIZE_IR",
+        JVMConfigurationKeys.SERIALIZE_IR,
+        JvmSerializeIrMode.Companion::fromString,
+    )
 }
 
 private sealed class PatternWithExtractor<E : Any> {