FIR: Split EnvironmentConfigurator to an interface and abstract class

It is needed to make it easier to write wrappers for configurators

compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives
 import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
 import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue
 import org.jetbrains.kotlin.test.services.DefaultsDsl
-import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.AbstractEnvironmentConfigurator
 import org.jetbrains.kotlin.test.util.LANGUAGE_FEATURE_PATTERN
 import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
@@ -52,7 +52,7 @@ class LanguageVersionSettingsBuilder {
 
     fun configureUsingDirectives(
         directives: RegisteredDirectives,
-        environmentConfigurators: List<EnvironmentConfigurator>,
+        environmentConfigurators: List<AbstractEnvironmentConfigurator>,
         targetBackend: TargetBackend?
     ) {
         val apiVersion = directives.singleOrZeroValue(LanguageSettingsDirectives.API_VERSION)

compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/AbstractEnvironmentConfigurator.kt

@@ -17,13 +17,21 @@ import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue
 import org.jetbrains.kotlin.test.model.ServicesAndDirectivesContainer
 import org.jetbrains.kotlin.test.model.TestModule
 
-abstract class EnvironmentConfigurator(protected val testServices: TestServices) : ServicesAndDirectivesContainer {
+abstract class AbstractEnvironmentConfigurator : ServicesAndDirectivesContainer {
+    abstract fun configureCompileConfigurationWithAdditionalConfigurationKeys(configuration: CompilerConfiguration, module: TestModule)
+
+    abstract fun provideAdditionalAnalysisFlags(directives: RegisteredDirectives, languageVersion: LanguageVersion): Map<AnalysisFlag<*>, Any?>
+
+    abstract fun registerCompilerExtensions(project: Project, module: TestModule)
+}
+
+abstract class EnvironmentConfigurator(protected val testServices: TestServices) : AbstractEnvironmentConfigurator() {
     protected val moduleStructure: TestModuleStructure
         get() = testServices.moduleStructure
 
     protected open fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) {}
 
-    fun configureCompileConfigurationWithAdditionalConfigurationKeys(
+    final override fun configureCompileConfigurationWithAdditionalConfigurationKeys(
         configuration: CompilerConfiguration,
         module: TestModule,
     ) {
@@ -35,14 +43,14 @@ abstract class EnvironmentConfigurator(protected val testServices: TestServices)
 
     open fun DirectiveToConfigurationKeyExtractor.provideConfigurationKeys() {}
 
-    open fun provideAdditionalAnalysisFlags(
+    override fun provideAdditionalAnalysisFlags(
         directives: RegisteredDirectives,
         languageVersion: LanguageVersion
     ): Map<AnalysisFlag<*>, Any?> {
         return emptyMap()
     }
 
-    open fun registerCompilerExtensions(project: Project) {}
+    override fun registerCompilerExtensions(project: Project, module: TestModule) {}
 }
 
 class DirectiveToConfigurationKeyExtractor {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt

@@ -28,7 +28,7 @@ class TestConfigurationBuilder {
 
     private val sourcePreprocessors: MutableList<Constructor<SourceFilePreprocessor>> = mutableListOf()
     private val additionalMetaInfoProcessors: MutableList<Constructor<AdditionalMetaInfoProcessor>> = mutableListOf()
-    private val environmentConfigurators: MutableList<Constructor<EnvironmentConfigurator>> = mutableListOf()
+    private val environmentConfigurators: MutableList<Constructor<AbstractEnvironmentConfigurator>> = mutableListOf()
     private val preAnalysisHandlers: MutableList<Constructor<PreAnalysisHandler>> = mutableListOf()
 
     private val additionalSourceProviders: MutableList<Constructor<AdditionalSourceProvider>> = mutableListOf()
@@ -46,7 +46,7 @@ class TestConfigurationBuilder {
     private val configurationsByNegativeTestDataCondition: MutableList<Pair<Regex, TestConfigurationBuilder.() -> Unit>> = mutableListOf()
     private val additionalServices: MutableList<ServiceRegistrationData> = mutableListOf()
 
-    private var compilerConfigurationProvider: ((Disposable, List<EnvironmentConfigurator>) -> CompilerConfigurationProvider)? = null
+    private var compilerConfigurationProvider: ((Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)? = null
     private var runtimeClasspathProviders: MutableList<Constructor<RuntimeClasspathProvider>> = mutableListOf()
 
     lateinit var testInfo: KotlinTestInfo
@@ -157,7 +157,7 @@ class TestConfigurationBuilder {
         this.directives += directives
     }
 
-    fun useConfigurators(vararg environmentConfigurators: Constructor<EnvironmentConfigurator>) {
+    fun useConfigurators(vararg environmentConfigurators: Constructor<AbstractEnvironmentConfigurator>) {
         this.environmentConfigurators += environmentConfigurators
     }
 
@@ -184,7 +184,7 @@ class TestConfigurationBuilder {
     }
 
     @TestInfrastructureInternals
-    fun useCustomCompilerConfigurationProvider(provider: (Disposable, List<EnvironmentConfigurator>) -> CompilerConfigurationProvider) {
+    fun useCustomCompilerConfigurationProvider(provider: (Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider) {
         compilerConfigurationProvider = provider
     }
 
@@ -256,7 +256,7 @@ class TestConfigurationBuilder {
             get() = builder.sourcePreprocessors
         val additionalMetaInfoProcessors: List<Constructor<AdditionalMetaInfoProcessor>>
             get() = builder.additionalMetaInfoProcessors
-        val environmentConfigurators: List<Constructor<EnvironmentConfigurator>>
+        val environmentConfigurators: List<Constructor<AbstractEnvironmentConfigurator>>
             get() = builder.environmentConfigurators
         val preAnalysisHandlers: List<Constructor<PreAnalysisHandler>>
             get() = builder.preAnalysisHandlers
@@ -286,7 +286,7 @@ class TestConfigurationBuilder {
         val additionalServices: List<ServiceRegistrationData>
             get() = builder.additionalServices
 
-        val compilerConfigurationProvider: ((Disposable, List<EnvironmentConfigurator>) -> CompilerConfigurationProvider)?
+        val compilerConfigurationProvider: ((Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)?
             get() = builder.compilerConfigurationProvider
         val runtimeClasspathProviders: List<Constructor<RuntimeClasspathProvider>>
             get() = builder.runtimeClasspathProviders

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt

@@ -30,7 +30,7 @@ class TestConfigurationImpl(
 
     sourcePreprocessors: List<Constructor<SourceFilePreprocessor>>,
     additionalMetaInfoProcessors: List<Constructor<AdditionalMetaInfoProcessor>>,
-    environmentConfigurators: List<Constructor<EnvironmentConfigurator>>,
+    environmentConfigurators: List<Constructor<AbstractEnvironmentConfigurator>>,
 
     additionalSourceProviders: List<Constructor<AdditionalSourceProvider>>,
     preAnalysisHandlers: List<Constructor<PreAnalysisHandler>>,
@@ -38,7 +38,7 @@ class TestConfigurationImpl(
     metaTestConfigurators: List<Constructor<MetaTestConfigurator>>,
     afterAnalysisCheckers: List<Constructor<AfterAnalysisChecker>>,
 
-    compilerConfigurationProvider: ((Disposable, List<EnvironmentConfigurator>) -> CompilerConfigurationProvider)?,
+    compilerConfigurationProvider: ((Disposable, List<AbstractEnvironmentConfigurator>) -> CompilerConfigurationProvider)?,
     runtimeClasspathProviders: List<Constructor<RuntimeClasspathProvider>>,
 
     override val metaInfoHandlerEnabled: Boolean,
@@ -70,7 +70,7 @@ class TestConfigurationImpl(
         }
     }
 
-    private val environmentConfigurators: List<EnvironmentConfigurator> =
+    private val environmentConfigurators: List<AbstractEnvironmentConfigurator> =
         environmentConfigurators
             .map { it.invoke(testServices) }
             .also { it.registerDirectivesAndServices() }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt

@@ -61,7 +61,7 @@ val TestServices.compilerConfigurationProvider: CompilerConfigurationProvider by
 
 open class CompilerConfigurationProviderImpl(
     override val testRootDisposable: Disposable,
-    val configurators: List<EnvironmentConfigurator>
+    val configurators: List<AbstractEnvironmentConfigurator>
 ) : CompilerConfigurationProvider() {
     private val cache: MutableMap<TestModule, KotlinCoreEnvironment> = mutableMapOf()
 
@@ -93,7 +93,7 @@ open class CompilerConfigurationProviderImpl(
             projectEnv,
             initialConfiguration,
             configFiles
-        ).also { configurators.forEach { it.registerCompilerExtensions(project) } }
+        ).also { configurators.forEach { it.registerCompilerExtensions(project, module) } }
     }
 
     @TestInfrastructureInternals

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt

@@ -42,7 +42,7 @@ class ModuleStructureExtractorImpl(
     testServices: TestServices,
     additionalSourceProviders: List<AdditionalSourceProvider>,
     moduleStructureTransformers: List<ModuleStructureTransformer>,
-    private val environmentConfigurators: List<EnvironmentConfigurator>
+    private val environmentConfigurators: List<AbstractEnvironmentConfigurator>
 ) : ModuleStructureExtractor(testServices, additionalSourceProviders, moduleStructureTransformers) {
     companion object {
         private val allowedExtensionsForFiles = listOf(".kt", ".kts", ".java", ".js", ".mjs")

plugins/atomicfu/atomicfu-compiler/test/org/jetbrains/kotlinx/atomicfu/AbstractAtomicfuJsIrTest.kt

@@ -39,7 +39,7 @@ class AtomicfuRuntimeClasspathProvider(testServices: TestServices) : RuntimeClas
 }
 
 class AtomicfuEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
-    override fun registerCompilerExtensions(project: Project) {
+    override fun registerCompilerExtensions(project: Project, module: TestModule) {
         IrGenerationExtension.registerExtension(project, AtomicfuLoweringExtension())
     }
 }

plugins/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/services/ExtensionRegistrarConfigurator.kt

@@ -10,11 +10,12 @@ import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.plugin.FirPluginPrototypeExtensionRegistrar
 import org.jetbrains.kotlin.ir.plugin.GeneratedDeclarationsIrBodyFiller
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.TestServices
 
 class ExtensionRegistrarConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
-    override fun registerCompilerExtensions(project: Project) {
+    override fun registerCompilerExtensions(project: Project, module: TestModule) {
         FirExtensionRegistrar.registerExtension(project, FirPluginPrototypeExtensionRegistrar())
         IrGenerationExtension.registerExtension(project, GeneratedDeclarationsIrBodyFiller())
     }

plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/RuntimeSearch.kt

@@ -58,7 +58,7 @@ internal fun TestConfigurationBuilder.configureForKotlinxSerialization(libraries
                     configuration.addJvmClasspathRoots(librariesPaths)
                 }
 
-                override fun registerCompilerExtensions(project: Project) {
+                override fun registerCompilerExtensions(project: Project, module: TestModule) {
                     SerializationComponentRegistrar.registerExtensions(project)
                 }
             }

plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/services/ParcelizeEnvironmentConfigurator.kt

@@ -31,7 +31,7 @@ class ParcelizeEnvironmentConfigurator(
         configuration.addJvmClasspathRoots(listOf(runtimeLibrary, androidExtensionsRuntimeLibrary, androidApiJar))
     }
 
-    override fun registerCompilerExtensions(project: Project) {
+    override fun registerCompilerExtensions(project: Project, module: TestModule) {
         if (useFirExtension) {
             FirExtensionRegistrar.registerExtension(project, FirParcelizeExtensionRegistrar())
             IrGenerationExtension.registerExtension(project, ParcelizeFirIrGeneratorExtension())

plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/services/SerializableLikeExtensionProvider.kt

@@ -11,11 +11,12 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
+import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.TestServices
 
 class SerializableLikeExtensionProvider(testServices: TestServices) : EnvironmentConfigurator(testServices) {
-    override fun registerCompilerExtensions(project: Project) {
+    override fun registerCompilerExtensions(project: Project, module: TestModule) {
         SyntheticResolveExtension.registerExtension(project, SerializableLike())
     }