From e5ee364419c66f4279acd23c0b02fcae69fe543a Mon Sep 17 00:00:00 2001 From: Ilya Chernikov Date: Thu, 14 Sep 2023 17:26:32 +0200 Subject: [PATCH] IC: Implement expect/actual tracking fixes NewMultiplatformIT.testIncrementalCompilation also #KT-61590 fixed --- .../fir/components/KtFirCompilerFacility.kt | 5 +- .../kotlin/cli/js/klib/compilerPipeline.kt | 1 + .../FirKotlinToJvmBytecodeCompiler.kt | 1 + .../jvm/compiler/pipeline/compilerPipeline.kt | 1 + .../kotlin/fir/pipeline/convertToIr.kt | 4 +- .../kotlin/fir/backend/Fir2IrConfiguration.kt | 2 + .../IncrementalFirJvmCompilerRunner.kt | 1 + .../actualizer/ExpectActualCollector.kt | 135 ++++++++++++------ .../backend/common/actualizer/IrActualizer.kt | 7 +- .../ir/IrActualizerAndPluginsFacade.kt | 1 + .../frontend/fir/Fir2IrJsResultsConverter.kt | 1 + .../frontend/fir/Fir2IrJvmResultsConverter.kt | 1 + .../fir/Fir2IrWasmResultsConverter.kt | 1 + .../kotlin/codegen/GenerationUtils.kt | 1 + .../jetbrains/kotlin/backend/konan/Fir2Ir.kt | 1 + 15 files changed, 117 insertions(+), 46 deletions(-) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompilerFacility.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompilerFacility.kt index f59794b3ce5..858846c2e8a 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompilerFacility.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompilerFacility.kt @@ -141,8 +141,9 @@ internal class KtFirCompilerFacility( effectiveConfiguration.languageVersionSettings, diagnosticsReporter, linkViaSignatures = false, - effectiveConfiguration[CommonConfigurationKeys.EVALUATED_CONST_TRACKER] ?: EvaluatedConstTracker.create(), - effectiveConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + evaluatedConstTracker = effectiveConfiguration[CommonConfigurationKeys.EVALUATED_CONST_TRACKER] ?: EvaluatedConstTracker.create(), + inlineConstTracker = effectiveConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + expectActualTracker = effectiveConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = true, useIrFakeOverrideBuilder = effectiveConfiguration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), ) diff --git a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt index c5d4740e7cf..3adabebbc08 100644 --- a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt +++ b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt @@ -240,6 +240,7 @@ fun transformFirToIr( evaluatedConstTracker = moduleStructure.compilerConfiguration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = null, + expectActualTracker = moduleStructure.compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = moduleStructure.compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt index 08a4495ebe0..6ca407b8547 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt @@ -243,6 +243,7 @@ object FirKotlinToJvmBytecodeCompiler { evaluatedConstTracker = configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), ) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt index 0e5136c34cb..4ad3ed0cd7c 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt @@ -184,6 +184,7 @@ fun convertAnalyzedFirToIr( evaluatedConstTracker = input.configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = input.configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + expectActualTracker = input.configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = input.configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), ) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt index 4239816d09f..8db11a992b5 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProv import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.moduleData import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.ir.IrBuiltIns import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmDescriptorMangler @@ -171,7 +170,8 @@ fun FirResult.convertToIrAndActualize( commonMemberStorage.symbolTable, irMangler, Fir2IrConverter.friendModulesMap(outputs.last().session), - fir2IrConfiguration.useIrFakeOverrideBuilder + fir2IrConfiguration.useIrFakeOverrideBuilder, + fir2IrConfiguration.expectActualTracker ) } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt index 5fd65a3eae8..83614082a1f 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.fir.backend import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.constant.EvaluatedConstTracker import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.InlineConstTracker /** @@ -36,6 +37,7 @@ data class Fir2IrConfiguration( val linkViaSignatures: Boolean, val evaluatedConstTracker: EvaluatedConstTracker, val inlineConstTracker: InlineConstTracker?, + val expectActualTracker: ExpectActualTracker?, val allowNonCachedDeclarations: Boolean, val useIrFakeOverrideBuilder: Boolean, ) diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt index b473c8e77a5..f3cb16c06e2 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt @@ -278,6 +278,7 @@ open class IncrementalFirJvmCompilerRunner( evaluatedConstTracker = configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), ) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt index a063e0eb630..8a3a88f9c84 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/ExpectActualCollector.kt @@ -6,21 +6,23 @@ package org.jetbrains.kotlin.backend.common.actualizer import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext +import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.PsiIrFileEntry import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.types.IrTypeSystemContext import org.jetbrains.kotlin.ir.types.classifierOrFail import org.jetbrains.kotlin.ir.util.callableId import org.jetbrains.kotlin.ir.util.classIdOrFail -import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid -import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid +import org.jetbrains.kotlin.ir.visitors.IrElementVisitor import org.jetbrains.kotlin.mpp.DeclarationSymbolMarker import org.jetbrains.kotlin.mpp.RegularClassSymbolMarker import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.resolve.calls.mpp.AbstractExpectActualCompatibilityChecker import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility +import java.io.File /** * This class is used to collect mapping between all expect and actuals declarations, which are declared in passed module fragments @@ -41,6 +43,7 @@ internal class ExpectActualCollector( private val dependentFragments: List, private val typeSystemContext: IrTypeSystemContext, private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext, + private val expectActualTracker: ExpectActualTracker?, ) { data class Result(val expectToActualMap: MutableMap, val classActualizationInfo: ClassActualizationInfo) @@ -61,12 +64,16 @@ internal class ExpectActualCollector( destination: MutableMap, classActualizationInfo: ClassActualizationInfo, ) { - val linkCollector = ExpectActualLinkCollector(destination, classActualizationInfo, typeSystemContext, diagnosticsReporter) - dependentFragments.forEach { linkCollector.visitModuleFragment(it) } + val linkCollector = ExpectActualLinkCollector() + val linkCollectorContext = + ExpectActualLinkCollector.MatchingContext( + typeSystemContext, destination, diagnosticsReporter, expectActualTracker, classActualizationInfo, null + ) + dependentFragments.forEach { linkCollector.visitModuleFragment(it, linkCollectorContext) } // It doesn't make sense to link expects from the last module because actuals always should be located in another module // Thus relevant actuals are always missing for the last module // But the collector should be run anyway to detect and report "hanging" expect declarations - linkCollector.visitModuleFragment(mainFragment) + linkCollector.visitModuleFragment(mainFragment, linkCollectorContext) } } @@ -75,7 +82,8 @@ internal data class ClassActualizationInfo( val actualClasses: Map, // mapping from classId to actual typealias val actualTypeAliases: Map, - val actualTopLevels: Map>, + val actualTopLevels: Map>, + val actualSymbolsToFile: Map, ) { fun getActualWithoutExpansion(classId: ClassId): IrSymbol? { return actualTypeAliases[classId] ?: actualClasses[classId] @@ -94,16 +102,19 @@ private class ActualDeclarationsCollector { return ClassActualizationInfo( collector.actualClasses, collector.actualTypeAliasesWithoutExpansion, - collector.actualTopLevels + collector.actualTopLevels, + collector.actualSymbolsToFile ) } } private val actualClasses: MutableMap = mutableMapOf() private val actualTypeAliasesWithoutExpansion: MutableMap = mutableMapOf() - private val actualTopLevels: MutableMap> = mutableMapOf() + private val actualTopLevels: MutableMap> = mutableMapOf() + private val actualSymbolsToFile: MutableMap = mutableMapOf() private val visitedActualClasses = mutableSetOf() + private var currentFile: IrFile? = null private fun collect(element: IrElement) { when (element) { @@ -112,6 +123,12 @@ private class ActualDeclarationsCollector { collect(file) } } + is IrFile -> { + currentFile = element + for (declaration in element.declarations) { + collect(declaration) + } + } is IrTypeAlias -> { if (!element.isActual) return @@ -120,6 +137,8 @@ private class ActualDeclarationsCollector { actualClasses[classId] = expandedTypeSymbol actualTypeAliasesWithoutExpansion[classId] = element.symbol + actualSymbolsToFile[expandedTypeSymbol] = currentFile + actualSymbolsToFile[element.symbol] = currentFile collect(expandedTypeSymbol.owner) } @@ -127,6 +146,7 @@ private class ActualDeclarationsCollector { if (element.isExpect || !visitedActualClasses.add(element)) return actualClasses[element.classIdOrFail] = element.symbol + actualSymbolsToFile[element.symbol] = currentFile for (declaration in element.declarations) { collect(declaration) } @@ -154,65 +174,86 @@ private class ActualDeclarationsCollector { if (callableId.classId == null) { actualTopLevels .getOrPut(callableId) { mutableListOf() } - .add(callableDeclaration) + .add(callableDeclaration.symbol) + actualSymbolsToFile[callableDeclaration.symbol] = currentFile } } } -private class ExpectActualLinkCollector( - private val destination: MutableMap, - private val classActualizationInfo: ClassActualizationInfo, - typeSystemContext: IrTypeSystemContext, - private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext, -) : IrElementVisitorVoid { - private val context = MatchingContext(typeSystemContext) +private class ExpectActualLinkCollector : IrElementVisitor { - override fun visitFunction(declaration: IrFunction) { + override fun visitFile(declaration: IrFile, data: MatchingContext) { + super.visitFile(declaration, data.withNewCurrentFile(declaration)) + } + + override fun visitFunction(declaration: IrFunction, data: MatchingContext) { if (declaration.isExpect) { - matchExpectCallable(declaration, declaration.callableId) + matchExpectCallable(declaration, declaration.callableId, data) } } - override fun visitProperty(declaration: IrProperty) { + override fun visitProperty(declaration: IrProperty, data: MatchingContext) { if (declaration.isExpect) { - matchExpectCallable(declaration, declaration.callableId) + matchExpectCallable(declaration, declaration.callableId, data) } } - private fun matchExpectCallable(declaration: IrDeclarationWithName, callableId: CallableId) { - val actualSymbols = classActualizationInfo.actualTopLevels[callableId]?.map { it.symbol }.orEmpty() - matchExpectDeclaration(declaration.symbol, actualSymbols) - } - - override fun visitClass(declaration: IrClass) { - if (!declaration.isExpect) return - val classId = declaration.classIdOrFail - val expectClassSymbol = declaration.symbol - val actualClassLikeSymbol = classActualizationInfo.getActualWithoutExpansion(classId) - matchExpectDeclaration(expectClassSymbol, listOfNotNull(actualClassLikeSymbol)) - } - - private fun matchExpectDeclaration(expectSymbol: IrSymbol, actualSymbols: List) { - AbstractExpectActualCompatibilityChecker.matchSingleExpectTopLevelDeclarationAgainstPotentialActuals( - expectSymbol, - actualSymbols, + private fun matchExpectCallable(declaration: IrDeclarationWithName, callableId: CallableId, context: MatchingContext) { + matchExpectDeclaration( + declaration.symbol, + context.classActualizationInfo.actualTopLevels[callableId].orEmpty(), context ) } - override fun visitElement(element: IrElement) { - element.acceptChildrenVoid(this) + override fun visitClass(declaration: IrClass, data: MatchingContext) { + if (!declaration.isExpect) return + val classId = declaration.classIdOrFail + val expectClassSymbol = declaration.symbol + val actualClassLikeSymbol = data.classActualizationInfo.getActualWithoutExpansion(classId) + matchExpectDeclaration(expectClassSymbol, listOfNotNull(actualClassLikeSymbol), data) } - private inner class MatchingContext( + private fun matchExpectDeclaration( + expectSymbol: IrSymbol, + actualSymbols: List, + context: MatchingContext + ) { + AbstractExpectActualCompatibilityChecker.matchSingleExpectTopLevelDeclarationAgainstPotentialActuals( + expectSymbol, + actualSymbols, + context, + ) + } + + override fun visitElement(element: IrElement, data: MatchingContext) { + element.acceptChildren(this, data) + } + + class MatchingContext( typeSystemContext: IrTypeSystemContext, + private val destination: MutableMap, + private val diagnosticsReporter: KtDiagnosticReporterWithImplicitIrBasedContext, + private val expectActualTracker: ExpectActualTracker?, + internal val classActualizationInfo: ClassActualizationInfo, + private val currentExpectFile: IrFile?, ) : IrExpectActualMatchingContext(typeSystemContext, classActualizationInfo.actualClasses) { + + private val currentExpectIoFile by lazy(LazyThreadSafetyMode.PUBLICATION) { currentExpectFile?.toIoFile() } + + fun withNewCurrentFile(newCurrentFile: IrFile) = + MatchingContext( + typeContext, destination, diagnosticsReporter, expectActualTracker, classActualizationInfo, newCurrentFile + ) + override fun onMatchedClasses(expectClassSymbol: IrClassSymbol, actualClassSymbol: IrClassSymbol) { destination[expectClassSymbol] = actualClassSymbol + expectActualTracker?.reportWithCurrentFile(actualClassSymbol) recordActualForExpectDeclaration(expectClassSymbol, actualClassSymbol, destination) } override fun onMatchedCallables(expectSymbol: IrSymbol, actualSymbol: IrSymbol) { + expectActualTracker?.reportWithCurrentFile(actualSymbol) recordActualForExpectDeclaration(expectSymbol, actualSymbol, destination) } @@ -233,5 +274,19 @@ private class ExpectActualLinkCollector( } } } + + private fun ExpectActualTracker.reportWithCurrentFile(actualSymbol: IrSymbol) { + if (currentExpectFile != null) { + val actualIoFile = classActualizationInfo.actualSymbolsToFile[actualSymbol]?.toIoFile() + if (actualIoFile != null) { + report(currentExpectIoFile!!, actualIoFile) + } + } + } } } + +private fun IrFile.toIoFile(): File? = when (val fe = fileEntry) { + is PsiIrFileEntry -> fe.psiFile.virtualFile.let { it.fileSystem.getNioPath(it)?.toFile() } + else -> File(fileEntry.name).takeIf { it.exists() } +} \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt index ad5f1a91707..fea3b9375e0 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/actualizer/IrActualizer.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.IrTypeSystemContext @@ -27,7 +28,8 @@ object IrActualizer { mangler: KotlinMangler.IrMangler, // TODO: drop this argument in favor of using [IrModuleDescriptor::shouldSeeInternalsOf] in FakeOverrideBuilder KT-61384 friendModules: Map>, - useIrFakeOverrideBuilder: Boolean + useIrFakeOverrideBuilder: Boolean, + expectActualTracker: ExpectActualTracker? ): IrActualizedResult { val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(diagnosticReporter, languageVersionSettings) @@ -37,7 +39,8 @@ object IrActualizer { mainFragment, dependentFragments, typeSystemContext, - ktDiagnosticReporter + ktDiagnosticReporter, + expectActualTracker ).collect() if (languageVersionSettings.supportsFeature(LanguageFeature.MultiplatformRestrictions)) { IrExpectActualAnnotationMatchingChecker(expectActualMap, actualDeclarations, typeSystemContext, ktDiagnosticReporter).check() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt index 1352df0de20..355b35f58ae 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrActualizerAndPluginsFacade.kt @@ -40,6 +40,7 @@ class IrActualizerAndPluginsFacade( inputArtifact.irMangler, mapOf(module.name to module.friendDependencies.map { it.moduleName }), useIrFakeOverrideBuilder = CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in module.directives, + expectActualTracker = null, ) inputArtifact.irActualizerResult = result } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt index 3342267b4b0..3110987ce83 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt @@ -168,6 +168,7 @@ fun ModuleCompilerAnalyzedOutput.convertToJsIr( evaluatedConstTracker = configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = null, + expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr() ) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt index 6fb3e2b679d..c946dbbed65 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt @@ -105,6 +105,7 @@ class Fir2IrJvmResultsConverter( evaluatedConstTracker = compilerConfiguration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(), ) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt index 0e250f186cd..48a0893f076 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt @@ -167,6 +167,7 @@ fun ModuleCompilerAnalyzedOutput.convertToWasmIr( evaluatedConstTracker = configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = null, + expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilderInConvertToIr(), ) diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt index fafdd3b66d4..7010dcd0812 100644 --- a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt @@ -137,6 +137,7 @@ object GenerationUtils { evaluatedConstTracker = configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER], + expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), ) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt index 9cd6fac6c02..95eb95a98a5 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt @@ -80,6 +80,7 @@ internal fun PhaseContext.fir2Ir( evaluatedConstTracker = configuration .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), inlineConstTracker = null, + expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER], allowNonCachedDeclarations = false, useIrFakeOverrideBuilder = configuration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER), )