[K2, MPP] Remove redundant expect declarations from klib metadata

^KT-57250 Fixed

Introduce flat Fir2IrActualizedResult

It contains output from Fir2Ir and IrActualizer

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

@@ -27,16 +27,14 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.messages.MessageUtil
-import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForJSIR
+import org.jetbrains.kotlin.cli.js.klib.*
-import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForWasm
-import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir
-import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization
-import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib
-import org.jetbrains.kotlin.cli.js.klib.transformFirToIr
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.Services
+import org.jetbrains.kotlin.config.getModuleNameForSource
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
@@ -68,7 +66,6 @@ import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.join
 import java.io.File
 import java.io.IOException
-import java.nio.charset.Charset
 
 private val K2JSCompilerArguments.granularity: JsGenerationGranularity
     get() = when {
@@ -493,14 +490,14 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
         ) ?: return null
 
         // FIR2IR
-        val irResult = transformFirToIr(moduleStructure, outputs, diagnosticsReporter)
+        val fir2IrActualizedResult = transformFirToIr(moduleStructure, outputs, diagnosticsReporter)
 
         // Serialize klib
         if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
             serializeFirKlib(
                 moduleStructure = moduleStructure,
                 firOutputs = outputs,
-                irResult = irResult,
+                fir2IrActualizedResult = fir2IrActualizedResult,
                 outputKlibPath = outputKlibPath,
                 messageCollector = messageCollector,
                 diagnosticsReporter = diagnosticsReporter,

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt

@@ -26,15 +26,12 @@ import org.jetbrains.kotlin.fir.BinaryModuleData
 import org.jetbrains.kotlin.fir.DependencyListForCliModule
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrResult
 import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
+import org.jetbrains.kotlin.fir.backend.extractFirDeclarations
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
-import org.jetbrains.kotlin.fir.pipeline.FirResult
+import org.jetbrains.kotlin.fir.pipeline.*
-import org.jetbrains.kotlin.fir.pipeline.ModuleCompilerAnalyzedOutput
-import org.jetbrains.kotlin.fir.pipeline.buildResolveAndCheckFir
-import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.serialization.FirElementAwareSerializableStringTable
 import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension
@@ -103,7 +100,7 @@ fun transformFirToIr(
     moduleStructure: ModulesStructure,
     firOutputs: List<ModuleCompilerAnalyzedOutput>,
     diagnosticsReporter: PendingDiagnosticsCollectorWithSuppress,
-): Fir2IrResult {
+): Fir2IrActualizedResult {
     val fir2IrExtensions = Fir2IrExtensions.Default
 
     var builtInsModule: KotlinBuiltIns? = null
@@ -149,7 +146,7 @@ fun transformFirToIr(
 fun serializeFirKlib(
     moduleStructure: ModulesStructure,
     firOutputs: List<ModuleCompilerAnalyzedOutput>,
-    irResult: Fir2IrResult,
+    fir2IrActualizedResult: Fir2IrActualizedResult,
     outputKlibPath: String,
     messageCollector: MessageCollector,
     diagnosticsReporter: BaseDiagnosticsCollector,
@@ -169,6 +166,8 @@ fun serializeFirKlib(
 
     val metadataVersion = moduleStructure.compilerConfiguration.metadataVersion()
 
+    val actualizedExpectDeclarations = fir2IrActualizedResult.irActualizationResult.extractFirDeclarations()
+
     serializeModuleIntoKlib(
         moduleStructure.compilerConfiguration[CommonConfigurationKeys.MODULE_NAME]!!,
         moduleStructure.compilerConfiguration,
@@ -176,7 +175,7 @@ fun serializeFirKlib(
         sourceFiles,
         klibPath = outputKlibPath,
         moduleStructure.allDependencies,
-        irResult.irModuleFragment,
+        fir2IrActualizedResult.irModuleFragment,
         expectDescriptorToSymbol = mutableMapOf(),
         cleanFiles = icData,
         nopack = true,
@@ -191,6 +190,7 @@ fun serializeFirKlib(
             firFile,
             session,
             scopeSession,
+            actualizedExpectDeclarations,
             FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()),
             moduleStructure.compilerConfiguration.languageVersionSettings,
         )

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

@@ -153,7 +153,7 @@ object FirKotlinToJvmBytecodeCompiler {
         performanceManager?.notifyIRTranslationStarted()
 
         val fir2IrExtensions = JvmFir2IrExtensions(moduleConfiguration, JvmIrDeserializerImpl(), JvmIrMangler)
-        val fir2IrResult = firResult.convertToIrAndActualizeForJvm(
+        val fir2IrAndIrActualizerResult = firResult.convertToIrAndActualizeForJvm(
             fir2IrExtensions,
             irGenerationExtensions,
             linkViaSignatures = moduleConfiguration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
@@ -165,7 +165,7 @@ object FirKotlinToJvmBytecodeCompiler {
 
         val generationState = runBackend(
             allSources,
-            fir2IrResult,
+            fir2IrAndIrActualizerResult,
             fir2IrExtensions,
             diagnosticsReporter
         )
@@ -219,11 +219,11 @@ object FirKotlinToJvmBytecodeCompiler {
 
     private fun CompilationContext.runBackend(
         ktFiles: List<KtFile>,
-        fir2IrResult: Fir2IrResult,
+        fir2IrActualizedResult: Fir2IrActualizedResult,
         extensions: JvmGeneratorExtensions,
         diagnosticsReporter: BaseDiagnosticsCollector
     ): GenerationState {
-        val (moduleFragment, components) = fir2IrResult
+        val (moduleFragment, components, pluginContext, irActualizationResult) = fir2IrActualizedResult
         val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext
         val codegenFactory = JvmIrCodegenFactory(
             moduleConfiguration,
@@ -252,7 +252,7 @@ object FirKotlinToJvmBytecodeCompiler {
         generationState.oldBEInitTrace(ktFiles)
         codegenFactory.generateModuleInFrontendIRMode(
             generationState, moduleFragment, components.symbolTable, components.irProviders,
-            extensions, FirJvmBackendExtension(components), fir2IrResult.pluginContext
+            extensions, FirJvmBackendExtension(components, irActualizationResult), pluginContext
         ) {
             performanceManager?.notifyIRLoweringFinished()
             performanceManager?.notifyIRGenerationStarted()

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt

@@ -231,7 +231,7 @@ fun convertAnalyzedFirToIr(
             IrGenerationExtension.getInstances(it)
         } ?: emptyList()
     val linkViaSignatures = input.configuration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES)
-    val (irModuleFragment, components, pluginContext) =
+    val (irModuleFragment, components, pluginContext, irActualizationResult) =
         analysisResults.convertToIrAndActualizeForJvm(
             extensions, irGenerationExtensions, linkViaSignatures,
             environment.diagnosticsReporter, input.configuration.languageVersionSettings
@@ -243,7 +243,8 @@ fun convertAnalyzedFirToIr(
         extensions,
         irModuleFragment,
         components,
-        pluginContext
+        pluginContext,
+        irActualizationResult
     )
 }
 
@@ -287,7 +288,7 @@ fun generateCodeFromIr(
         input.components.symbolTable,
         input.components.irProviders,
         input.extensions,
-        FirJvmBackendExtension(input.components),
+        FirJvmBackendExtension(input.components, input.irActualizationResult),
         input.pluginContext
     ) {
         performanceManager?.notifyIRLoweringFinished()

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipelineData.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.cli.jvm.compiler.pipeline
 
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
@@ -43,5 +44,6 @@ data class ModuleCompilerIrBackendInput(
     val extensions: JvmFir2IrExtensions,
     val irModuleFragment: IrModuleFragment,
     val components: Fir2IrComponents,
-    val pluginContext: Fir2IrPluginContext
+    val pluginContext: Fir2IrPluginContext,
+    val irActualizationResult: IrActualizationResult?
 )

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/FirMetadataSerializer.kt

@@ -163,6 +163,7 @@ internal class FirMetadataSerializer(
                     firFile,
                     session,
                     scopeSession,
+                    actualizedExpectDeclarations = null,
                     FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()),
                     languageVersionSettings
                 )

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.pipeline
 
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.backend.common.actualizer.IrActualizer
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor
@@ -22,6 +23,7 @@ import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrMangler
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.util.IdSignatureComposer
 import org.jetbrains.kotlin.ir.util.KotlinMangler
@@ -34,13 +36,20 @@ data class ModuleCompilerAnalyzedOutput(
     val fir: List<FirFile>
 )
 
+data class Fir2IrActualizedResult(
+    val irModuleFragment: IrModuleFragment,
+    val components: Fir2IrComponents,
+    val pluginContext: Fir2IrPluginContext,
+    val irActualizationResult: IrActualizationResult?,
+)
+
 fun FirResult.convertToIrAndActualizeForJvm(
     fir2IrExtensions: Fir2IrExtensions,
     irGeneratorExtensions: Collection<IrGenerationExtension>,
     linkViaSignatures: Boolean,
     diagnosticReporter: DiagnosticReporter,
     languageVersionSettings: LanguageVersionSettings,
-): Fir2IrResult = this.convertToIrAndActualize(
+): Fir2IrActualizedResult = this.convertToIrAndActualize(
     fir2IrExtensions,
     irGeneratorExtensions,
     linkViaSignatures = linkViaSignatures,
@@ -63,8 +72,9 @@ fun FirResult.convertToIrAndActualize(
     diagnosticReporter: DiagnosticReporter,
     languageVersionSettings: LanguageVersionSettings,
     fir2IrResultPostCompute: Fir2IrResult.() -> Unit = {},
-): Fir2IrResult {
+): Fir2IrActualizedResult {
-    val result: Fir2IrResult
+    val fir2IrResult: Fir2IrResult
+    val actualizationResult: IrActualizationResult?
 
     val commonMemberStorage = Fir2IrCommonMemberStorage(
         generateSignatures = linkViaSignatures,
@@ -75,7 +85,7 @@ fun FirResult.convertToIrAndActualize(
     when (outputs.size) {
         0 -> error("No modules found")
         1 -> {
-            result = outputs.single().convertToIr(
+            fir2IrResult = outputs.single().convertToIr(
                 fir2IrExtensions,
                 irGeneratorExtensions,
                 linkViaSignatures = linkViaSignatures,
@@ -85,6 +95,7 @@ fun FirResult.convertToIrAndActualize(
                 visibilityConverter,
                 kotlinBuiltIns,
             )
+            actualizationResult = null
         }
         else -> {
             val platformOutput = outputs.last()
@@ -107,7 +118,7 @@ fun FirResult.convertToIrAndActualize(
                     }
                 }
             }
-            result = platformOutput.convertToIr(
+            fir2IrResult = platformOutput.convertToIr(
                 fir2IrExtensions,
                 irGeneratorExtensions,
                 linkViaSignatures = linkViaSignatures,
@@ -120,8 +131,8 @@ fun FirResult.convertToIrAndActualize(
                 fir2IrResultPostCompute(it)
             }
 
-            IrActualizer.actualize(
+            actualizationResult = IrActualizer.actualize(
-                result.irModuleFragment,
+                fir2IrResult.irModuleFragment,
                 commonIrOutputs.map { it.irModuleFragment },
                 diagnosticReporter,
                 languageVersionSettings
@@ -129,7 +140,8 @@ fun FirResult.convertToIrAndActualize(
         }
     }
 
-    return result
+    val (irModuleFragment, components, pluginContext) = fir2IrResult
+    return Fir2IrActualizedResult(irModuleFragment, components, pluginContext, actualizationResult)
 }
 
 private fun ModuleCompilerAnalyzedOutput.convertToIr(

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -69,15 +69,24 @@ class FirElementSerializer private constructor(
     private val contractSerializer = FirContractSerializer()
     private val extensionDeclarationProviders = session.extensionService.declarationForMetadataProviders
 
-    fun packagePartProto(packageFqName: FqName, files: List<FirFile>): ProtoBuf.Package.Builder {
+    fun packagePartProto(
+        packageFqName: FqName,
+        files: List<FirFile>,
+        actualizedExpectDeclarations: Set<FirDeclaration>?
+    ): ProtoBuf.Package.Builder {
         val builder = ProtoBuf.Package.newBuilder()
 
         fun addDeclaration(declaration: FirDeclaration, onUnsupportedDeclaration: (FirDeclaration) -> Unit) {
-            when (declaration) {
+            if (declaration is FirMemberDeclaration) {
-                is FirProperty -> propertyProto(declaration)?.let { builder.addProperty(it) }
+                if (!declaration.shouldBeSerialized(actualizedExpectDeclarations)) return
-                is FirSimpleFunction -> functionProto(declaration)?.let { builder.addFunction(it) }
+                when (declaration) {
-                is FirTypeAlias -> typeAliasProto(declaration)?.let { builder.addTypeAlias(it) }
+                    is FirProperty -> propertyProto(declaration)?.let { builder.addProperty(it) }
-                else -> onUnsupportedDeclaration(declaration)
+                    is FirSimpleFunction -> functionProto(declaration)?.let { builder.addFunction(it) }
+                    is FirTypeAlias -> typeAliasProto(declaration)?.let { builder.addTypeAlias(it) }
+                    else -> onUnsupportedDeclaration(declaration)
+                }
+            } else {
+                onUnsupportedDeclaration(declaration)
             }
         }
 

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/firKlibSerialization.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.serialization.SerializableStringTable
 
 fun serializeSingleFirFile(
     file: FirFile, session: FirSession, scopeSession: ScopeSession,
+    actualizedExpectDeclarations: Set<FirDeclaration>?,
     serializerExtension: FirKLibSerializerExtension,
     languageVersionSettings: LanguageVersionSettings,
 ): ProtoBuf.PackageFragment {
@@ -31,21 +32,26 @@ fun serializeSingleFirFile(
     // TODO: split package fragment (see klib serializer)
     // TODO: handle incremental/monolothic (see klib serializer) - maybe externally
 
-    val packageProto = packageSerializer.packagePartProto(file.packageFqName, listOf(file)).build()
+    val packageProto = packageSerializer.packagePartProto(file.packageFqName, listOf(file), actualizedExpectDeclarations).build()
 
-    fun List<FirDeclaration>.makeClassesProtoWithNested(): List<Pair<ProtoBuf.Class, Int>> =
+    fun List<FirDeclaration>.makeClassesProtoWithNested(): List<Pair<ProtoBuf.Class, Int>> {
-        // TODO: filter out expects
+        return filterIsInstance<FirClass>().filter { it.shouldBeSerialized(actualizedExpectDeclarations) }
-        filterIsInstance<FirClass>().sortedBy { it.classId.asFqNameString() }.flatMap {
+            .sortedBy { it.classId.asFqNameString() }
-            val classSerializer = FirElementSerializer.create(session, scopeSession, it, serializerExtension, null,
+            .flatMap {
-                approximator, languageVersionSettings)
+                val classSerializer = FirElementSerializer.create(
-            val index = classSerializer.stringTable.getFqNameIndex(it)
+                    session, scopeSession, it, serializerExtension, null,
-            listOf(classSerializer.classProto(it).build() to index) + it.declarations.makeClassesProtoWithNested()
+                    approximator, languageVersionSettings
-        }
+                )
+                val index = classSerializer.stringTable.getFqNameIndex(it)
+                listOf(classSerializer.classProto(it).build() to index) + it.declarations.makeClassesProtoWithNested()
+            }
+    }
 
     val classesProto = file.declarations.makeClassesProtoWithNested()
 
     val hasTopLevelDeclarations = file.declarations.any {
-        it is FirProperty || it is FirSimpleFunction || it is FirTypeAlias
+        it is FirMemberDeclaration && it.shouldBeSerialized(actualizedExpectDeclarations) &&
+                (it is FirProperty || it is FirSimpleFunction || it is FirTypeAlias)
     }
 
     return buildKlibPackageFragment(

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/serializationUtil.kt

@@ -7,6 +7,9 @@ package org.jetbrains.kotlin.fir.serialization
 
 import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.diagnostics.ConeIntermediateDiagnostic
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -43,3 +46,7 @@ fun ConeKotlinType.suspendFunctionTypeToFunctionTypeWithContinuation(session: Fi
         attributes = fullyExpandedType.attributes
     )
 }
+
+fun FirMemberDeclaration.shouldBeSerialized(actualizedExpectDeclaration: Set<FirDeclaration>?): Boolean {
+    return !isExpect || actualizedExpectDeclaration == null || this !in actualizedExpectDeclaration
+}

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmBackendExtension.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.backend.jvm
 
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmBackendExtension
 import org.jetbrains.kotlin.backend.jvm.metadata.MetadataSerializer
@@ -15,7 +16,10 @@ import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.org.objectweb.asm.Type
 
-class FirJvmBackendExtension(private val components: Fir2IrComponents) : JvmBackendExtension {
+class FirJvmBackendExtension(
+    private val components: Fir2IrComponents,
+    private val irActualizationResult: IrActualizationResult?
+) : JvmBackendExtension {
     override fun createSerializer(
         context: JvmBackendContext,
         klass: IrClass,
@@ -23,7 +27,15 @@ class FirJvmBackendExtension(private val components: Fir2IrComponents) : JvmBack
         bindings: JvmSerializationBindings,
         parentSerializer: MetadataSerializer?
     ): MetadataSerializer {
-        return makeFirMetadataSerializerForIrClass(components.session, context, klass, bindings, components, parentSerializer)
+        return makeFirMetadataSerializerForIrClass(
+            components.session,
+            context,
+            klass,
+            bindings,
+            components,
+            parentSerializer,
+            irActualizationResult
+        )
     }
 
     override fun generateMetadataExtraFlags(abiStability: JvmAbiStability?): Int =

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.backend.jvm
 
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
 import org.jetbrains.kotlin.backend.jvm.metadata.MetadataSerializer
@@ -14,6 +15,7 @@ import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.fir.backend.FirMetadataSource
+import org.jetbrains.kotlin.fir.backend.extractFirDeclarations
 import org.jetbrains.kotlin.fir.containingClassForLocal
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.*
@@ -45,7 +47,8 @@ fun makeFirMetadataSerializerForIrClass(
     irClass: IrClass,
     serializationBindings: JvmSerializationBindings,
     components: Fir2IrComponents,
-    parent: MetadataSerializer?
+    parent: MetadataSerializer?,
+    irActualizationResult: IrActualizationResult?
 ): FirMetadataSerializer {
     val approximator = TypeApproximatorForMetadataSerializer(session)
     val localDelegatedProperties = context.localDelegatedProperties[irClass.attributeOwnerId]?.map {
@@ -62,8 +65,9 @@ fun makeFirMetadataSerializerForIrClass(
         approximator,
         makeElementSerializer(
             irClass.metadata, components.session, components.scopeSession, firSerializerExtension, approximator, parent,
-            context.state.configuration.languageVersionSettings,
+            context.state.configuration.languageVersionSettings
-        )
+        ),
+        irActualizationResult
     )
 }
 
@@ -75,7 +79,8 @@ fun makeLocalFirMetadataSerializerForMetadataSource(
     globalSerializationBindings: JvmSerializationBindings,
     parent: MetadataSerializer?,
     targetId: TargetId,
-    configuration: CompilerConfiguration
+    configuration: CompilerConfiguration,
+    irActualizationResult: IrActualizationResult?
 ): FirMetadataSerializer {
     val serializationBindings = JvmSerializationBindings()
     val approximator = TypeApproximatorForMetadataSerializer(session)
@@ -106,8 +111,9 @@ fun makeLocalFirMetadataSerializerForMetadataSource(
         approximator,
         makeElementSerializer(
             metadata, session, scopeSession, firSerializerExtension, approximator, parent,
-            configuration.languageVersionSettings,
+            configuration.languageVersionSettings
-        )
+        ),
+        irActualizationResult
     )
 }
 
@@ -116,16 +122,17 @@ class FirMetadataSerializer(
     private val serializationBindings: JvmSerializationBindings,
     private val serializerExtension: FirJvmSerializerExtension,
     private val approximator: AbstractTypeApproximator,
-    internal val serializer: FirElementSerializer?
+    internal val serializer: FirElementSerializer?,
+    irActualizationResult: IrActualizationResult?
 ) : MetadataSerializer {
+    private val actualizedExpectDeclarations = irActualizationResult.extractFirDeclarations()
 
     override fun serialize(metadata: MetadataSource): Pair<MessageLite, JvmStringTable>? {
         val message = when (metadata) {
             is FirMetadataSource.Class -> serializer!!.classProto(metadata.fir).build()
             is FirMetadataSource.File ->
-                serializer!!.packagePartProto(metadata.files.first().packageFqName, metadata.files).apply {
+                serializer!!.packagePartProto(metadata.files.first().packageFqName, metadata.files, actualizedExpectDeclarations)
-                    serializerExtension.serializeJvmPackage(this)
+                    .apply { serializerExtension.serializeJvmPackage(this) }.build()
-                }.build()
             is FirMetadataSource.Function -> {
                 val withTypeParameters = metadata.fir.copyToFreeAnonymousFunction(approximator)
                 serializationBindings.get(FirJvmSerializerExtension.METHOD_FOR_FIR_FUNCTION, metadata.fir)?.let {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.backend
 
 import com.intellij.psi.PsiCompiledElement
 import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.builtins.StandardNames.DATA_CLASS_COMPONENT_PREFIX
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.startOffsetSkippingComments
@@ -748,3 +749,7 @@ fun FirCallableDeclaration.contextReceiversForFunctionOrContainingProperty(): Li
         this.propertySymbol.fir.contextReceivers
     else
         this.contextReceivers
+
+fun IrActualizationResult?.extractFirDeclarations(): Set<FirDeclaration>? {
+    return this?.actualizedExpectDeclarations?.mapNotNullTo(mutableSetOf()) { ((it as IrMetadataSourceOwner).metadata as FirMetadataSource).fir }
+}

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -33381,6 +33381,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/noArgActualConstructor.kt");
                 }
 
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -33381,6 +33381,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/noArgActualConstructor.kt");
                 }
 
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -275,7 +275,7 @@ class IncrementalFirJvmCompilerRunner(
             val extensions = JvmFir2IrExtensions(configuration, JvmIrDeserializerImpl(), JvmIrMangler)
             val irGenerationExtensions =
                 (projectEnvironment as? VfsBasedProjectEnvironment)?.project?.let { IrGenerationExtension.getInstances(it) }.orEmpty()
-            val platformIrOutput = cycleResult.convertToIrAndActualizeForJvm(
+            val (irModuleFragment, components, pluginContext, irActualizationResult) = cycleResult.convertToIrAndActualizeForJvm(
                 extensions,
                 irGenerationExtensions,
                 linkViaSignatures = false,
@@ -289,9 +289,10 @@ class IncrementalFirJvmCompilerRunner(
                 targetId,
                 configuration,
                 extensions,
-                platformIrOutput.irModuleFragment,
+                irModuleFragment,
-                platformIrOutput.components,
+                components,
-                platformIrOutput.pluginContext
+                pluginContext,
+                irActualizationResult
             )
 
             val codegenOutput = generateCodeFromIr(irInput, compilerEnvironment, performanceManager)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/incrementalFirCacheUtils.kt

@@ -52,7 +52,8 @@ internal fun collectNewDirtySources(
                         globalSerializationBindings,
                         data.lastOrNull(),
                         targetId,
-                        configuration
+                        configuration,
+                        irActualizationResult = null
                     )
                     data.push(serializer)
                     body(serializer)

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt

@@ -12,28 +12,40 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.name.FqName
 
+data class IrActualizationResult(val actualizedExpectDeclarations: List<IrDeclaration>)
+
 object IrActualizer {
     fun actualize(
         mainFragment: IrModuleFragment,
         dependentFragments: List<IrModuleFragment>,
         diagnosticReporter: DiagnosticReporter,
         languageVersionSettings: LanguageVersionSettings
-    ) {
+    ): IrActualizationResult {
         val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(diagnosticReporter, languageVersionSettings)
         val (expectActualMap, expectActualTypeAliasMap) = ExpectActualCollector(mainFragment, dependentFragments, ktDiagnosticReporter).collect()
         FunctionDefaultParametersActualizer(expectActualMap).actualize()
-        removeExpectDeclarations(dependentFragments, expectActualMap)
+        val removedExpectDeclarationMetadata = removeExpectDeclarations(dependentFragments, expectActualMap)
         addMissingFakeOverrides(expectActualMap, dependentFragments, expectActualTypeAliasMap, ktDiagnosticReporter)
         linkExpectToActual(expectActualMap, dependentFragments)
         mergeIrFragments(mainFragment, dependentFragments)
+        return IrActualizationResult(removedExpectDeclarationMetadata)
     }
 
-    private fun removeExpectDeclarations(dependentFragments: List<IrModuleFragment>, expectActualMap: Map<IrSymbol, IrSymbol>) {
+    private fun removeExpectDeclarations(dependentFragments: List<IrModuleFragment>, expectActualMap: Map<IrSymbol, IrSymbol>): List<IrDeclaration> {
+        val removedDeclarationMetadata = mutableListOf<IrDeclaration>()
         for (fragment in dependentFragments) {
             for (file in fragment.files) {
-                file.declarations.removeIf { shouldRemoveExpectDeclaration(it, expectActualMap) }
+                file.declarations.removeIf {
+                    if (shouldRemoveExpectDeclaration(it, expectActualMap)) {
+                        removedDeclarationMetadata.add(it)
+                        true
+                    } else {
+                        false
+                    }
+                }
             }
         }
+        return removedDeclarationMetadata
     }
 
     private fun shouldRemoveExpectDeclaration(irDeclaration: IrDeclaration, expectActualMap: Map<IrSymbol, IrSymbol>): Boolean {

compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt

@@ -0,0 +1,37 @@
+// IGNORE_BACKEND_K1: JVM, JVM_IR, JS, JS_IR, JS_IR_ES6, NATIVE, WASM
+// ISSUE: KT-57250
+// WITH_STDLIB
+// !OPT_IN: kotlin.ExperimentalMultiplatform
+// !LANGUAGE: +MultiPlatformProjects
+
+// MODULE: common
+// TARGET_PLATFORM: Common
+// FILE: common.kt
+
+expect class C()
+
+@OptionalExpectation
+expect annotation class WithActual(val x: Int)
+
+@OptionalExpectation
+expect annotation class WithoutActual(val s: String)
+
+expect fun k(): String
+
+// MODULE: platform()()(common)
+// FILE: lib.kt
+
+actual class C {
+    fun o() = "O"
+}
+
+actual annotation class WithActual(actual val x: Int)
+
+actual fun k() = "K"
+
+// MODULE: main(platform)
+// FILE: main.kt
+
+@WithActual(42)
+@WithoutActual("OK")
+fun box() = C().o() + k()

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java

@@ -31964,6 +31964,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                 public void testNoArgActualConstructor() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/noArgActualConstructor.kt");
                 }
+
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
             }
 
             @Nested

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -33381,6 +33381,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/noArgActualConstructor.kt");
                 }
 
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java

@@ -33381,6 +33381,12 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/noArgActualConstructor.kt");
                 }
 
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
+
                 @Test
                 @TestMetadata("valueClasses.kt")
                 public void testValueClasses() throws Exception {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.test.backend.ir
 
 import org.jetbrains.kotlin.KtSourceFile
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -39,7 +40,7 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput<IrBackendInput>() {
         val expectDescriptorToSymbol: MutableMap<DeclarationDescriptor, IrSymbol>, // TODO: abstract from descriptors
         val diagnosticsCollector: BaseDiagnosticsCollector,
         val hasErrors: Boolean,
-        val serializeSingleFile: (KtSourceFile) -> ProtoBuf.PackageFragment
+        val serializeSingleFile: (KtSourceFile, IrActualizationResult?) -> ProtoBuf.PackageFragment
     ) : IrBackendInput() {
         override val irModuleFragment: IrModuleFragment
             get() = mainModuleFragment

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt

@@ -112,7 +112,7 @@ class ClassicFrontend2IrConverter(
             expectDescriptorToSymbol = expectDescriptorToSymbol,
             diagnosticsCollector = DiagnosticReporterFactory.createReporter(),
             hasErrors
-        ) { file ->
+        ) { file, _ ->
             metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor)
         }
     }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.*
 import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProvider
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.serialization.FirElementAwareSerializableStringTable
@@ -100,6 +101,8 @@ class Fir2IrJsResultsConverter(
 
         val metadataVersion = configuration.metadataVersion(module.languageVersionSettings.languageVersion)
 
+        var actualizedExpectDeclarations: Set<FirDeclaration>? = null
+
         return IrBackendInput.JsIrBackendInput(
             mainIrPart,
             dependentIrParts,
@@ -109,13 +112,17 @@ class Fir2IrJsResultsConverter(
             expectDescriptorToSymbol = mutableMapOf(),
             diagnosticsCollector = DiagnosticReporterFactory.createReporter(),
             hasErrors = inputArtifact.hasErrors
-        ) { file ->
+        ) { file, irActualizationResult ->
             val (firFile, components) = firFilesAndComponentsBySourceFile[file]
                 ?: error("cannot find FIR file by source file ${file.name} (${file.path})")
+            if (actualizedExpectDeclarations == null && irActualizationResult != null) {
+                actualizedExpectDeclarations = irActualizationResult.extractFirDeclarations()
+            }
             serializeSingleFirFile(
                 firFile,
                 components.session,
                 components.scopeSession,
+                actualizedExpectDeclarations,
                 FirKLibSerializerExtension(components.session, metadataVersion, FirElementAwareSerializableStringTable()),
                 configuration.languageVersionSettings,
             )

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrResultsConverter.kt

@@ -108,7 +108,7 @@ class Fir2IrResultsConverter(
                 phaseConfig,
                 components.irProviders,
                 fir2IrExtensions,
-                FirJvmBackendExtension(components),
+                FirJvmBackendExtension(components, irActualizationResult = null),
                 pluginContext,
                 notifyCodegenStart = {},
             )

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -160,7 +160,7 @@ object GenerationUtils {
         generationState.oldBEInitTrace(files)
         codegenFactory.generateModuleInFrontendIRMode(
             generationState, moduleFragment, components.symbolTable, components.irProviders,
-            fir2IrExtensions, FirJvmBackendExtension(components), pluginContext,
+            fir2IrExtensions, FirJvmBackendExtension(components, irActualizationResult = null), pluginContext,
         ) {}
 
         generationState.factory.done()

compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -27159,6 +27159,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/noArgActualConstructor.kt");
                 }
 
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void ignoreRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
+
                 private void runTest(String testDataFilePath) throws Exception {
                     KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
                 }

js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt

@@ -14,7 +14,8 @@ import org.jetbrains.kotlin.codegen.ProjectInfo
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
-import org.jetbrains.kotlin.ir.backend.js.*
+import org.jetbrains.kotlin.ir.backend.js.MainModule
+import org.jetbrains.kotlin.ir.backend.js.ModulesStructure
 import org.jetbrains.kotlin.test.TargetBackend
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -66,12 +67,12 @@ abstract class FirAbstractInvalidationTest(
         )
 
         if (outputs != null) {
-            val irResult = transformFirToIr(moduleStructure, outputs, diagnosticsReporter)
+            val fir2IrActualizedResult = transformFirToIr(moduleStructure, outputs, diagnosticsReporter)
 
             serializeFirKlib(
                 moduleStructure = moduleStructure,
                 firOutputs = outputs,
-                irResult = irResult,
+                fir2IrActualizedResult = fir2IrActualizedResult,
                 outputKlibPath = outputKlibFile.absolutePath,
                 messageCollector = messageCollector,
                 diagnosticsReporter = diagnosticsReporter,

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/FirJsKlibBackendFacade.kt

@@ -65,14 +65,17 @@ class FirJsKlibBackendFacade(
         val diagnosticReporter = DiagnosticReporterFactory.createReporter()
 
         if (firstTimeCompilation) {
-            if (module.frontendKind == FrontendKinds.FIR && module.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)) {
+            val irActualizationResult =
-                IrActualizer.actualize(
+                if (module.frontendKind == FrontendKinds.FIR && module.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)) {
-                    inputArtifact.mainModuleFragment,
+                    IrActualizer.actualize(
-                    inputArtifact.dependentModuleFragments,
+                        inputArtifact.mainModuleFragment,
-                    diagnosticReporter,
+                        inputArtifact.dependentModuleFragments,
-                    configuration.languageVersionSettings
+                        diagnosticReporter,
-                )
+                        configuration.languageVersionSettings
-            }
+                    )
+                } else {
+                    null
+                }
 
             serializeModuleIntoKlib(
                 configuration[CommonConfigurationKeys.MODULE_NAME]!!,
@@ -88,9 +91,10 @@ class FirJsKlibBackendFacade(
                 perFile = false,
                 containsErrorCode = inputArtifact.hasErrors,
                 abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data
-                jsOutputName = null,
+                jsOutputName = null
-                inputArtifact.serializeSingleFile
+            ) {
-            )
+                inputArtifact.serializeSingleFile(it, irActualizationResult)
+            }
         }
 
         // TODO: consider avoiding repeated libraries resolution

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/JsKlibBackendFacade.kt

@@ -61,9 +61,10 @@ class JsKlibBackendFacade(
                 perFile = false,
                 containsErrorCode = inputArtifact.hasErrors,
                 abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data
-                jsOutputName = null,
+                jsOutputName = null
-                inputArtifact.serializeSingleFile
+            ) {
-            )
+                inputArtifact.serializeSingleFile(it, null)
+            }
         }
 
         val dependencies = JsEnvironmentConfigurator.getAllRecursiveDependenciesFor(module, testServices).toList()

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsCodegenBoxTestGenerated.java

@@ -23104,6 +23104,12 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                 public void testExpectProperty() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                 }
+
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
             }
 
             @Nested

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java

@@ -23128,6 +23128,12 @@ public class FirJsCodegenBoxTestGenerated extends AbstractFirJsCodegenBoxTest {
                 public void testExpectProperty() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                 }
+
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
             }
 
             @Nested

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java

@@ -23128,6 +23128,12 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                 public void testExpectProperty() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                 }
+
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
             }
 
             @Nested

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java

@@ -23128,6 +23128,12 @@ public class IrJsES6CodegenBoxTestGenerated extends AbstractIrJsES6CodegenBoxTes
                 public void testExpectProperty() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                 }
+
+                @Test
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
             }
 
             @Nested

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

@@ -18,13 +18,15 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.deserialization.PlatformDependentTypeTransformer
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.descriptors.konan.isNativeStdlib
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
-import org.jetbrains.kotlin.fir.backend.Fir2IrResult
+import org.jetbrains.kotlin.fir.backend.Fir2IrPluginContext
 import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.library.metadata.KlibMetadataFactories
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -66,7 +68,7 @@ internal fun PhaseContext.fir2Ir(
     }
     val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter()
 
-    val fir2irResult = input.firResult.convertToIrAndActualize(
+    val (irModuleFragment, components, pluginContext, irActualizationResult) = input.firResult.convertToIrAndActualize(
             fir2IrExtensions,
             IrGenerationExtension.getInstances(config.project),
             linkViaSignatures = false,
@@ -79,11 +81,11 @@ internal fun PhaseContext.fir2Ir(
     ).also {
         (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors }
     }
-    assert(fir2irResult.irModuleFragment.name.isSpecial) {
+    assert(irModuleFragment.name.isSpecial) {
-        "`${fir2irResult.irModuleFragment.name}` must be Name.special, since it's required by KlibMetadataModuleDescriptorFactoryImpl.createDescriptorOptionalBuiltIns()"
+        "`${irModuleFragment.name}` must be Name.special, since it's required by KlibMetadataModuleDescriptorFactoryImpl.createDescriptorOptionalBuiltIns()"
     }
 
-    val symbols = createKonanSymbols(fir2irResult)
+    val symbols = createKonanSymbols(irModuleFragment, components, pluginContext)
     // TODO KT-55580 Invoke CopyDefaultValuesToActualPhase, same as PsiToir phase does.
 
     val renderDiagnosticNames = configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME)
@@ -93,15 +95,17 @@ internal fun PhaseContext.fir2Ir(
         throw KonanCompilationException("Compilation failed: there were some diagnostics during fir2ir")
     }
 
-    return Fir2IrOutput(input.firResult, fir2irResult, symbols)
+    return Fir2IrOutput(input.firResult, symbols, irModuleFragment, components, pluginContext, irActualizationResult)
 }
 
 private fun PhaseContext.createKonanSymbols(
-        fir2irResult: Fir2IrResult,
+        irModuleFragment: IrModuleFragment,
+        components: Fir2IrComponents,
+        pluginContext: Fir2IrPluginContext,
 ): KonanSymbolsOverFir {
-    val moduleDescriptor = fir2irResult.irModuleFragment.descriptor
+    val moduleDescriptor = irModuleFragment.descriptor
-    val symbolTable = SymbolTable(KonanIdSignaturer(KonanManglerDesc), fir2irResult.pluginContext.irFactory)
+    val symbolTable = SymbolTable(KonanIdSignaturer(KonanManglerDesc), pluginContext.irFactory)
     val descriptorsLookup = DescriptorsLookup(moduleDescriptor.builtIns as KonanBuiltIns)
 
-    return KonanSymbolsOverFir(this, descriptorsLookup, fir2irResult.components.irBuiltIns, symbolTable, symbolTable.lazyWrapper)
+    return KonanSymbolsOverFir(this, descriptorsLookup, components.irBuiltIns, symbolTable, symbolTable.lazyWrapper)
 }

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

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.backend.extractFirDeclarations
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -53,12 +54,13 @@ internal fun PhaseContext.firSerializer(
                     ?: configuration.languageVersionSettings.languageVersion.toMetadataVersion()
 
     val resolvedLibraries = config.resolvedLibraries.getFullResolvedList(TopologicalLibraryOrder) // FIXME KT-55603
+    val actualizedFirDeclarations = input.irActualizationResult.extractFirDeclarations()
     return serializeNativeModule(
             configuration = configuration,
             messageLogger = configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None,
             sourceFiles,
             resolvedLibraries.map { it.library as KonanLibrary },
-            input.fir2irResult.irModuleFragment,
+            input.irModuleFragment,
             expectDescriptorToSymbol = mutableMapOf() // TODO: expect -> actual mapping
     ) { file ->
         val (firFile, session, scopeSession) = firFilesAndSessionsBySourceFile[file]
@@ -67,6 +69,7 @@ internal fun PhaseContext.firSerializer(
                 firFile,
                 session,
                 scopeSession,
+                actualizedFirDeclarations,
                 FirNativeKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()),
                 configuration.languageVersionSettings,
         )

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/BackendPhases.kt

@@ -15,8 +15,8 @@ import org.jetbrains.kotlin.backend.konan.driver.utilities.getDefaultIrActions
 import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
 import org.jetbrains.kotlin.backend.konan.lower.ExpectToActualDefaultValueCopier
 import org.jetbrains.kotlin.backend.konan.lower.SpecialBackendChecksTraversal
-import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.backend.konan.makeEntryPoint
+import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -47,10 +47,10 @@ internal val K2SpecialBackendChecksPhase = createSimpleNamedCompilerPhase<PhaseC
         "SpecialBackendChecks",
         "Special backend checks",
 ) { context, input ->
-    val moduleFragment = input.fir2irResult.irModuleFragment
+    val moduleFragment = input.irModuleFragment
     SpecialBackendChecksTraversal(
             context,
-            InteropBuiltIns(input.fir2irResult.pluginContext.moduleDescriptor.builtIns as KonanBuiltIns),
+            InteropBuiltIns(input.pluginContext.moduleDescriptor.builtIns as KonanBuiltIns),
             input.symbols,
             moduleFragment.irBuiltins
     ).lower(moduleFragment)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/driver/phases/Fir2Ir.kt

@@ -5,17 +5,23 @@
 
 package org.jetbrains.kotlin.backend.konan.driver.phases
 
+import org.jetbrains.kotlin.backend.common.actualizer.IrActualizationResult
 import org.jetbrains.kotlin.backend.konan.driver.PhaseContext
 import org.jetbrains.kotlin.backend.konan.driver.PhaseEngine
 import org.jetbrains.kotlin.backend.konan.fir2Ir
 import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
-import org.jetbrains.kotlin.fir.backend.Fir2IrResult
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.Fir2IrPluginContext
 import org.jetbrains.kotlin.fir.pipeline.FirResult
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 
 internal data class Fir2IrOutput(
         val firResult: FirResult,
-        val fir2irResult: Fir2IrResult,
+        val symbols: KonanSymbols,
-        val symbols: KonanSymbols
+        val irModuleFragment: IrModuleFragment,
+        val components: Fir2IrComponents,
+        val pluginContext: Fir2IrPluginContext,
+        val irActualizationResult: IrActualizationResult?
 )
 
 internal val Fir2IrPhase = createSimpleNamedCompilerPhase(

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java

@@ -26554,6 +26554,12 @@ public class FirNativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTe
                     public void testExpectProperty() throws Exception {
                         runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                     }
+
+                    @Test
+                    @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                    public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                        runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                    }
                 }
 
                 @Nested

native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/K1NativeCodegenBoxTestGenerated.java

@@ -26251,6 +26251,12 @@ public class K1NativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTes
                     public void testExpectProperty() throws Exception {
                         runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                     }
+
+                    @Test
+                    @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                    public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                        runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                    }
                 }
 
                 @Nested

wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java

@@ -20699,6 +20699,11 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest
                 public void testExpectProperty() throws Exception {
                     runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt");
                 }
+
+                @TestMetadata("removeExpectDeclarationsFromMetadata.kt")
+                public void testRemoveExpectDeclarationsFromMetadata() throws Exception {
+                    runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt");
+                }
             }
 
             @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/defaultArguments")