[FIR2IR] De-duplicate creation of Fir2IrConfiguration

This will help to prevent inconsistencies between creating the configuration in the actual compiler pipeline and in compiler tests.
2023-12-13 15:50:17 +01:00
parent 4d4c95b643
commit a0ba878b1d
10 changed files with 88 additions and 88 deletions
@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fir.analysis.diagnostics.toFirDiagnostics
@@ -261,17 +260,7 @@ internal class KtFirCompilerFacility(
        effectiveConfiguration: CompilerConfiguration,
        irGeneratorExtensions: List<IrGenerationExtension>
    ): Fir2IrActualizedResult {
-        val fir2IrConfiguration = Fir2IrConfiguration(
-            session.languageVersionSettings,
-            diagnosticReporter,
-            linkViaSignatures = false,
-            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),
-        )
+        val fir2IrConfiguration = Fir2IrConfiguration.forAnalysisApi(effectiveConfiguration, session.languageVersionSettings, diagnosticReporter)
        val firResult = FirResult(listOf(ModuleCompilerAnalyzedOutput(session, session.getScopeSession(), firFiles)))

        return firResult.convertToIrAndActualize(
@@ -242,17 +242,7 @@ fun transformFirToIr(
    val firResult = FirResult(firOutputs)
    return firResult.convertToIrAndActualize(
        fir2IrExtensions,
-        Fir2IrConfiguration(
-            languageVersionSettings = moduleStructure.compilerConfiguration.languageVersionSettings,
-            diagnosticReporter = diagnosticsReporter,
-            linkViaSignatures = false,
-            evaluatedConstTracker = moduleStructure.compilerConfiguration
-                .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
-            inlineConstTracker = null,
-            expectActualTracker = moduleStructure.compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
-            allowNonCachedDeclarations = false,
-            useIrFakeOverrideBuilder = true
-        ),
+        Fir2IrConfiguration.forKlibCompilation(moduleStructure.compilerConfiguration, diagnosticsReporter),
        IrGenerationExtension.getInstances(moduleStructure.project),
        signatureComposer = DescriptorSignatureComposerStub(JsManglerDesc),
        irMangler = JsManglerIr,
@@ -199,17 +199,7 @@ fun FirResult.convertToIrAndActualizeForJvm(
    diagnosticsReporter: DiagnosticReporter,
    irGeneratorExtensions: Collection<IrGenerationExtension>,
 ): Fir2IrActualizedResult {
-    val fir2IrConfiguration = Fir2IrConfiguration(
-        languageVersionSettings = configuration.languageVersionSettings,
-        diagnosticReporter = diagnosticsReporter,
-        linkViaSignatures = configuration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
-        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),
-    )
+    val fir2IrConfiguration = Fir2IrConfiguration.forJvmCompilation(configuration, diagnosticsReporter)

    return convertToIrAndActualize(
        fir2IrExtensions,
@@ -16,25 +16,28 @@

 package org.jetbrains.kotlin.fir.backend

-import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.*
 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
+import org.jetbrains.kotlin.ir.util.SymbolTable

 /**
- * @param linkViaSignatures enables calculation of signatures for IR symbols and filling the SymbolTable with them.
- *  This parameter should be set to true if caller will rely on the content of the symbol table in future (like for KLib generation)
+ * @param linkViaSignatures Enables calculation of signatures for IR symbols and filling the [SymbolTable] with them.
+ *  This parameter should be set to `true` if the caller relies on the content of the symbol table in the future.
+ *  Note: this parameter is to be removed ([KT-64809](https://youtrack.jetbrains.com/issue/KT-64809)).
 *
 * @param allowNonCachedDeclarations
- *  Normally, FIR-to-IR caches all declarations it meets in a compiled module.
+ *  Normally, FIR2IR caches all declarations it meets in a compiled module.
 *  It means asking for an IR element of a non-cached declaration is a sign of inconsistent state.
 *  Code generation in the IDE is trickier, though, as declarations from any module can be potentially referenced.
 *  For such a scenario, there is a flag that relaxes consistency checks.
 *
- *  @param useIrFakeOverrideBuilder enables creation of fake-overrides using IR f/o generator instead of FIR2IR one. KT-61514
+ * @param useIrFakeOverrideBuilder Enables creation of fake-overrides using the IR f/o generator instead of the FIR2IR one.
+ *  See [KT-61514](https://youtrack.jetbrains.com/issue/KT-61514).
 */
-data class Fir2IrConfiguration(
+class Fir2IrConfiguration private constructor(
    val languageVersionSettings: LanguageVersionSettings,
    val diagnosticReporter: DiagnosticReporter,
    val linkViaSignatures: Boolean,
@@ -43,4 +46,63 @@ data class Fir2IrConfiguration(
    val expectActualTracker: ExpectActualTracker?,
    val allowNonCachedDeclarations: Boolean,
    val useIrFakeOverrideBuilder: Boolean,
-)
+) {
+
+    companion object {
+        fun forJvmCompilation(
+            compilerConfiguration: CompilerConfiguration,
+            diagnosticReporter: DiagnosticReporter,
+        ): Fir2IrConfiguration =
+            Fir2IrConfiguration(
+                languageVersionSettings = compilerConfiguration.languageVersionSettings,
+                diagnosticReporter = diagnosticReporter,
+                linkViaSignatures = compilerConfiguration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
+                evaluatedConstTracker = compilerConfiguration.putIfAbsent(
+                    CommonConfigurationKeys.EVALUATED_CONST_TRACKER,
+                    EvaluatedConstTracker.create(),
+                ),
+                inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+                expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
+                allowNonCachedDeclarations = false,
+                useIrFakeOverrideBuilder = compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
+            )
+
+        fun forKlibCompilation(
+            compilerConfiguration: CompilerConfiguration,
+            diagnosticReporter: DiagnosticReporter,
+            linkViaSignatures: Boolean = false, // FIXME(KT-64809): This parameter is only used in irText tests, we need to remove it.
+        ): Fir2IrConfiguration =
+            Fir2IrConfiguration(
+                languageVersionSettings = compilerConfiguration.languageVersionSettings,
+                diagnosticReporter = diagnosticReporter,
+                linkViaSignatures = linkViaSignatures,
+                evaluatedConstTracker = compilerConfiguration.putIfAbsent(
+                    CommonConfigurationKeys.EVALUATED_CONST_TRACKER,
+                    EvaluatedConstTracker.create(),
+                ),
+                inlineConstTracker = null,
+                expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
+                allowNonCachedDeclarations = false,
+                useIrFakeOverrideBuilder = true,
+            )
+
+        fun forAnalysisApi(
+            compilerConfiguration: CompilerConfiguration,
+            languageVersionSettings: LanguageVersionSettings,
+            diagnosticReporter: DiagnosticReporter,
+        ): Fir2IrConfiguration =
+            Fir2IrConfiguration(
+                languageVersionSettings = languageVersionSettings,
+                diagnosticReporter = diagnosticReporter,
+                linkViaSignatures = false,
+                evaluatedConstTracker = compilerConfiguration.putIfAbsent(
+                    CommonConfigurationKeys.EVALUATED_CONST_TRACKER,
+                    EvaluatedConstTracker.create(),
+                ),
+                inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+                expectActualTracker = compilerConfiguration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
+                allowNonCachedDeclarations = true,
+                useIrFakeOverrideBuilder = compilerConfiguration.getBoolean(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER),
+            )
+    }
+}
@@ -247,7 +247,7 @@ object CodegenTestDirectives : SimpleDirectivesContainer() {

    val ENABLE_IR_FAKE_OVERRIDE_GENERATION by directive(
        description = """
-            Enables fake-override generation in FIR2IR using IR f/o generator. KT-61514
+            Enables fake-override generation in FIR2IR using IR f/o generator on JVM. KT-61514
        """.trimIndent()
    )

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.library.unresolvedDependencies
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
+import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
 import org.jetbrains.kotlin.test.model.BackendKinds
 import org.jetbrains.kotlin.test.model.Frontend2BackendConverter
 import org.jetbrains.kotlin.test.model.FrontendKinds
@@ -67,24 +68,6 @@ abstract class AbstractFir2IrNonJvmResultsConverter(
            }
        }

-    private fun createFir2IrConfiguration(
-        module: TestModule,
-        configuration: CompilerConfiguration,
-        diagnosticReporter: BaseDiagnosticsCollector
-    ): Fir2IrConfiguration {
-        return Fir2IrConfiguration(
-            languageVersionSettings = configuration.languageVersionSettings,
-            diagnosticReporter = diagnosticReporter,
-            linkViaSignatures = true,
-            evaluatedConstTracker = configuration
-                .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
-            inlineConstTracker = null,
-            expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
-            allowNonCachedDeclarations = false,
-            useIrFakeOverrideBuilder = module.shouldUseIrFakeOverrideBuilder()
-        )
-    }
-
    private fun transformInternal(
        module: TestModule,
        inputArtifact: FirOutputArtifact
@@ -99,7 +82,12 @@ abstract class AbstractFir2IrNonJvmResultsConverter(
        val libraries = resolveLibraries(module, compilerConfiguration)
        val (dependencies, builtIns) = loadResolvedLibraries(libraries, compilerConfiguration.languageVersionSettings, testServices)

-        val fir2IrConfiguration = createFir2IrConfiguration(module, compilerConfiguration, diagnosticReporter)
+        val fir2IrConfiguration = Fir2IrConfiguration.forKlibCompilation(
+            compilerConfiguration,
+            diagnosticReporter,
+            // FIXME(KT-64809): This is for irText tests. Remove this when we stop building signatures from FIR entirely.
+            linkViaSignatures = LanguageSettingsDirectives.LINK_VIA_SIGNATURES in module.directives,
+        )
        val fir2irResult = inputArtifact.toFirResult().convertToIrAndActualize(
            Fir2IrExtensions.Default,
            fir2IrConfiguration,
@@ -83,17 +83,7 @@ class Fir2IrJvmResultsConverter(
        val diagnosticReporter = DiagnosticReporterFactory.createReporter()

        val compilerConfiguration = compilerConfigurationProvider.getCompilerConfiguration(module)
-        val fir2IrConfiguration = Fir2IrConfiguration(
-            languageVersionSettings = module.languageVersionSettings,
-            diagnosticReporter = diagnosticReporter,
-            linkViaSignatures = compilerConfiguration.getBoolean(JVMConfigurationKeys.LINK_VIA_SIGNATURES),
-            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.shouldUseIrFakeOverrideBuilder(),
-        )
+        val fir2IrConfiguration = Fir2IrConfiguration.forJvmCompilation(compilerConfiguration, diagnosticReporter)

        val fir2irResult = inputArtifact.toFirResult().convertToIrAndActualize(
            fir2IrExtensions,
@@ -10,17 +10,12 @@ import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.platform.isJs
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
-import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
 import org.jetbrains.kotlin.test.model.BackendKinds
 import org.jetbrains.kotlin.test.model.Frontend2BackendConverter
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices

-fun TestModule.shouldUseIrFakeOverrideBuilder(): Boolean {
-    return !targetPlatform.isJvm() || CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in directives
-}
-
 class Fir2IrResultsConverter(
    testServices: TestServices
 ) : Frontend2BackendConverter<FirOutputArtifact, IrBackendInput>(
@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.platform.konan.isNative
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
+import org.jetbrains.kotlin.test.directives.CodegenTestDirectives
 import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.TestModule
@@ -129,6 +130,11 @@ fun createCompilerConfiguration(module: TestModule, configurators: List<Abstract
    val configuration = CompilerConfiguration()
    configuration[CommonConfigurationKeys.MODULE_NAME] = module.name

+    if (module.targetPlatform.isJvm() && CodegenTestDirectives.ENABLE_IR_FAKE_OVERRIDE_GENERATION in module.directives) {
+        // For non-JVM platforms, the IR-based fake override builder is enabled unconditionally; on JVM it must be enabled manually.
+        configuration.put(CommonConfigurationKeys.USE_IR_FAKE_OVERRIDE_BUILDER, true)
+    }
+
    if (JsEnvironmentConfigurationDirectives.GENERATE_STRICT_IMPLICIT_EXPORT in module.directives) {
        configuration.put(JSConfigurationKeys.GENERATE_STRICT_IMPLICIT_EXPORT, true)
    }
@@ -93,17 +93,7 @@ internal fun PhaseContext.fir2Ir(
    }
    val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter()

-    val fir2IrConfiguration = Fir2IrConfiguration(
-            languageVersionSettings = configuration.languageVersionSettings,
-            diagnosticReporter = diagnosticsReporter,
-            linkViaSignatures = false,
-            evaluatedConstTracker = configuration
-                    .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
-            inlineConstTracker = null,
-            expectActualTracker = configuration[CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER],
-            allowNonCachedDeclarations = false,
-            useIrFakeOverrideBuilder = true,
-    )
+    val fir2IrConfiguration = Fir2IrConfiguration.forKlibCompilation(configuration, diagnosticsReporter)
    val (irModuleFragment, components, pluginContext, irActualizedResult) = input.firResult.convertToIrAndActualize(
            NativeFir2IrExtensions,
            fir2IrConfiguration,