[Plugins] Introduce new API for registering compiler plugins

Original `ComponentRegistrar` exposes Project to its registration method,
  so plugins should manually register extensions to it. To prepare for
  possible unbound compiler from Project API in future new  `K2ComponentRegistrar`
  introduced which provides registration method without Project at all

plugins/allopen/allopen.cli/src/org/jetbrains/kotlin/allopen/AllOpenPlugin.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.allopen
 
-import com.intellij.mock.MockProject
 import org.jetbrains.kotlin.allopen.AllOpenConfigurationKeys.ANNOTATION
 import org.jetbrains.kotlin.allopen.AllOpenConfigurationKeys.PRESET
 import org.jetbrains.kotlin.allopen.AllOpenPluginNames.ANNOTATION_OPTION_NAME
@@ -15,7 +14,7 @@ import org.jetbrains.kotlin.compiler.plugin.*
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 
 object AllOpenConfigurationKeys {
     val ANNOTATION: CompilerConfigurationKey<List<String>> = CompilerConfigurationKey.create("annotation qualified name")
@@ -45,16 +44,16 @@ class AllOpenCommandLineProcessor : CommandLineProcessor {
     }
 }
 
-class AllOpenComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+class AllOpenComponentRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         val annotations = configuration.get(ANNOTATION)?.toMutableList() ?: mutableListOf()
         configuration.get(PRESET)?.forEach { preset ->
             SUPPORTED_PRESETS[preset]?.let { annotations += it }
         }
         if (annotations.isEmpty()) return
 
-        DeclarationAttributeAltererExtension.registerExtension(project, CliAllOpenDeclarationAttributeAltererExtension(annotations))
-        FirExtensionRegistrar.registerExtension(project, FirAllOpenExtensionRegistrar(annotations))
+        DeclarationAttributeAltererExtension.registerExtension(CliAllOpenDeclarationAttributeAltererExtension(annotations))
+        FirExtensionRegistrarAdapter.registerExtension(FirAllOpenExtensionRegistrar(annotations))
     }
 
     override val supportsK2: Boolean

plugins/allopen/test/org/jetbrains/kotlin/allopen/AllOpenEnvironmentConfigurator.kt

@@ -5,25 +5,24 @@
 
 package org.jetbrains.kotlin.allopen
 
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.allopen.fir.FirAllOpenExtensionRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.TestServices
 
 class AllOpenEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerCompilerExtensions(
+        module: TestModule,
+        configuration: CompilerConfiguration
+    ) {
         val annotations = AbstractAllOpenDeclarationAttributeAltererExtension.ANNOTATIONS_FOR_TESTS +
                 AllOpenPluginNames.SUPPORTED_PRESETS.flatMap { it.value }
 
-        DeclarationAttributeAltererExtension.registerExtension(
-            project,
-            CliAllOpenDeclarationAttributeAltererExtension(annotations)
-        )
-
-        FirExtensionRegistrar.registerExtension(project, FirAllOpenExtensionRegistrar(annotations))
+        DeclarationAttributeAltererExtension.registerExtension(CliAllOpenDeclarationAttributeAltererExtension(annotations))
+        FirExtensionRegistrarAdapter.registerExtension(FirAllOpenExtensionRegistrar(annotations))
     }
 }

plugins/atomicfu/atomicfu-compiler/src/org/jetbrains/kotlinx/atomicfu/compiler/extensions/AtomicfuComponentRegistrar.kt

@@ -16,22 +16,21 @@
 
 package org.jetbrains.kotlinx.atomicfu.compiler.extensions
 
-import com.intellij.mock.MockProject
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 
-class AtomicfuComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        registerExtensions(project)
+class AtomicfuComponentRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        Companion.registerExtensions(this)
     }
 
     override val supportsK2: Boolean
         get() = true
 
     companion object {
-        fun registerExtensions(project: Project) {
-            IrGenerationExtension.registerExtension(project, AtomicfuLoweringExtension()) }
+        fun registerExtensions(extensionStorage: ExtensionStorage) = with(extensionStorage) {
+            IrGenerationExtension.registerExtension(AtomicfuLoweringExtension())
+        }
     }
 }

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

@@ -34,7 +34,7 @@ open class AbstractAtomicfuJsIrTest : AbstractJsIrTest(
 }
 
 class AtomicfuEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
+    override fun legacyRegisterCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
         IrGenerationExtension.registerExtension(project, AtomicfuLoweringExtension())
     }
 }

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

@@ -11,6 +11,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.codegen.AbstractAsmLikeInstructionListingTest
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
@@ -53,8 +55,8 @@ private fun TestConfigurationBuilder.configureForKotlinxAtomicfu(librariesPaths:
                     configuration.addJvmClasspathRoots(librariesPaths)
                 }
 
-                override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
-                    AtomicfuComponentRegistrar.registerExtensions(project)
+                override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
+                    AtomicfuComponentRegistrar.registerExtensions(this)
                 }
             }
         })

plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/FirPluginPrototypeExtensionRegistrar.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.fir.plugin
 
-import com.intellij.mock.MockProject
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.fir.plugin.generators.*
 import org.jetbrains.kotlin.fir.plugin.types.FirNumberSignAttributeExtension
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.ir.plugin.GeneratedDeclarationsIrBodyFiller
 
 class FirPluginPrototypeExtensionRegistrar : FirExtensionRegistrar() {
@@ -32,9 +32,12 @@ class FirPluginPrototypeExtensionRegistrar : FirExtensionRegistrar() {
     }
 }
 
-class FirPluginPrototypeComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        FirExtensionRegistrar.registerExtension(project, FirPluginPrototypeExtensionRegistrar())
-        IrGenerationExtension.registerExtension(project, GeneratedDeclarationsIrBodyFiller())
+class FirPluginPrototypeComponentRegistrar : CompilerPluginRegistrar() {
+    override val supportsK2: Boolean
+        get() = true
+
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        FirExtensionRegistrarAdapter.registerExtension(FirPluginPrototypeExtensionRegistrar())
+        IrGenerationExtension.registerExtension(GeneratedDeclarationsIrBodyFiller())
     }
 }

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

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.plugin.services
 
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.fir.plugin.FirPluginPrototypeExtensionRegistrar
 import org.jetbrains.kotlin.ir.plugin.GeneratedDeclarationsIrBodyFiller
 import org.jetbrains.kotlin.test.model.TestModule
@@ -16,8 +16,8 @@ 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, module: TestModule, configuration: CompilerConfiguration) {
-        FirExtensionRegistrar.registerExtension(project, FirPluginPrototypeExtensionRegistrar())
-        IrGenerationExtension.registerExtension(project, GeneratedDeclarationsIrBodyFiller())
+    override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
+        FirExtensionRegistrarAdapter.registerExtension(FirPluginPrototypeExtensionRegistrar())
+        IrGenerationExtension.registerExtension(GeneratedDeclarationsIrBodyFiller())
     }
 }

plugins/imports-dumper/src/org/jetbrains/kotlin/importsDumper/ImportsDumperComponentRegistrar.kt

@@ -5,14 +5,16 @@
 
 package org.jetbrains.kotlin.importsDumper
 
-import com.intellij.mock.MockProject
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 
-class ImportsDumperComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+class ImportsDumperComponentRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         val destinationPath = configuration[ImportsDumperConfigurationKeys.DESTINATION] ?: return
-        AnalysisHandlerExtension.registerExtension(project, ImportsDumperExtension(destinationPath))
+        AnalysisHandlerExtension.registerExtension(ImportsDumperExtension(destinationPath))
     }
-}
+
+    override val supportsK2: Boolean
+        get() = false
+}

plugins/jvm-abi-gen/src/org/jetbrains/kotlin/jvm/abi/JvmAbiComponentRegistrar.kt

@@ -5,21 +5,20 @@
 
 package org.jetbrains.kotlin.jvm.abi
 
-import com.intellij.mock.MockProject
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.codegen.extensions.ClassFileFactoryFinalizerExtension
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import java.io.File
 
-class JvmAbiComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+class JvmAbiComponentRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         val outputPath = configuration.getNotNull(JvmAbiConfigurationKeys.OUTPUT_PATH)
         val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
         if (configuration.get(JvmAbiConfigurationKeys.LEGACY_ABI_GEN, false)) {
@@ -33,14 +32,14 @@ class JvmAbiComponentRegistrar : ComponentRegistrar {
             val extension = JvmAbiAnalysisHandlerExtension(configuration.copy().apply {
                 put(JVMConfigurationKeys.OUTPUT_DIRECTORY, File(outputPath))
             })
-            AnalysisHandlerExtension.registerExtension(project, extension)
+            AnalysisHandlerExtension.registerExtension(extension)
         } else {
             // Use the single-pass implementation, using the new ABI flag in the metadata.
             configuration.put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true)
             val builderExtension = JvmAbiClassBuilderInterceptor()
             val outputExtension = JvmAbiOutputExtension(File(outputPath), builderExtension.abiClassInfo, messageCollector)
-            ClassBuilderInterceptorExtension.registerExtension(project, builderExtension)
-            ClassFileFactoryFinalizerExtension.registerExtension(project, outputExtension)
+            ClassBuilderInterceptorExtension.registerExtension( builderExtension)
+            ClassFileFactoryFinalizerExtension.registerExtension( outputExtension)
         }
     }
 

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationComponentRegistrar.kt

@@ -5,11 +5,9 @@
 
 package org.jetbrains.kotlinx.serialization.compiler.extensions
 
-import com.intellij.mock.MockProject
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.useInstance
@@ -24,28 +22,31 @@ import org.jetbrains.kotlin.serialization.DescriptorSerializerPlugin
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
 import org.jetbrains.kotlinx.serialization.compiler.diagnostic.SerializationPluginDeclarationChecker
 
-class SerializationComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        registerExtensions(project)
+class SerializationComponentRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        Companion.registerExtensions(this)
     }
 
+    override val supportsK2: Boolean
+        get() = false
+
     companion object {
-        fun registerExtensions(project: Project) {
+        fun registerExtensions(extensionStorage: ExtensionStorage) = with(extensionStorage) {
             // This method is never called in the IDE, therefore this extension is not available there.
             // Since IDE does not perform any serialization of descriptors, metadata written to the 'serializationDescriptorSerializer'
             // is never deleted, effectively causing memory leaks.
             // So we create SerializationDescriptorSerializerPlugin only outside of IDE.
             val serializationDescriptorSerializer = SerializationDescriptorSerializerPlugin()
-            DescriptorSerializerPlugin.registerExtension(project, serializationDescriptorSerializer)
+            DescriptorSerializerPlugin.registerExtension(serializationDescriptorSerializer)
             registerProtoExtensions()
 
-            SyntheticResolveExtension.registerExtension(project, SerializationResolveExtension(serializationDescriptorSerializer))
+            SyntheticResolveExtension.registerExtension(SerializationResolveExtension(serializationDescriptorSerializer))
 
-            ExpressionCodegenExtension.registerExtension(project, SerializationCodegenExtension(serializationDescriptorSerializer))
-            JsSyntheticTranslateExtension.registerExtension(project, SerializationJsExtension(serializationDescriptorSerializer))
-            IrGenerationExtension.registerExtension(project, SerializationLoweringExtension(serializationDescriptorSerializer))
+            ExpressionCodegenExtension.registerExtension(SerializationCodegenExtension(serializationDescriptorSerializer))
+            JsSyntheticTranslateExtension.registerExtension(SerializationJsExtension(serializationDescriptorSerializer))
+            IrGenerationExtension.registerExtension(SerializationLoweringExtension(serializationDescriptorSerializer))
 
-            StorageComponentContainerContributor.registerExtension(project, SerializationPluginComponentContainerContributor())
+            StorageComponentContainerContributor.registerExtension(SerializationPluginComponentContainerContributor())
         }
 
         private fun registerProtoExtensions() {

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.ObsoleteTestInfrastructure
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.codegen.AbstractAsmLikeInstructionListingTest
+import org.jetbrains.kotlin.compiler.plugin.registerExtensionsForTest
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationComponentRegistrar
 import java.io.File
@@ -24,7 +25,9 @@ abstract class AbstractSerializationIrBytecodeListingTest : AbstractAsmLikeInstr
     override val backend = TargetBackend.JVM_IR
 
     override fun setupEnvironment(environment: KotlinCoreEnvironment) {
-        SerializationComponentRegistrar.registerExtensions(environment.project)
+        registerExtensionsForTest(environment.project, environment.configuration) {
+            SerializationComponentRegistrar.registerExtensions(this)
+        }
         environment.updateClasspath(listOf(JvmClasspathRoot(coreLibraryPath!!)))
     }
 }

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.ObsoleteTestInfrastructure
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.codegen.AbstractAsmLikeInstructionListingTest
+import org.jetbrains.kotlin.compiler.plugin.registerExtensionsForTest
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationComponentRegistrar
 
 @OptIn(ObsoleteTestInfrastructure::class)
@@ -16,7 +17,9 @@ abstract class AbstractSerializationPluginBytecodeListingTest : AbstractAsmLikeI
     private val coreLibraryPath = getSerializationCoreLibraryJar()
 
     override fun setupEnvironment(environment: KotlinCoreEnvironment) {
-        SerializationComponentRegistrar.registerExtensions(environment.project)
+        registerExtensionsForTest(environment.project, environment.configuration) {
+            SerializationComponentRegistrar.registerExtensions(this)
+        }
         environment.updateClasspath(listOf(JvmClasspathRoot(coreLibraryPath!!)))
     }
 }

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.ObsoleteTestInfrastructure
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
+import org.jetbrains.kotlin.compiler.plugin.registerExtensionsForTest
 import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationComponentRegistrar
 
 @OptIn(ObsoleteTestInfrastructure::class)
@@ -16,7 +17,9 @@ abstract class AbstractSerializationPluginDiagnosticTest : AbstractDiagnosticsTe
     private val coreLibraryPath = getSerializationCoreLibraryJar()
 
     override fun setupEnvironment(environment: KotlinCoreEnvironment) {
-        SerializationComponentRegistrar.registerExtensions(environment.project)
+        registerExtensionsForTest(environment.project, environment.configuration) {
+            SerializationComponentRegistrar.registerExtensions(this)
+        }
         environment.updateClasspath(listOf(JvmClasspathRoot(coreLibraryPath!!)))
     }
 }

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

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlinx.serialization
 
-import com.intellij.openapi.project.Project
 import junit.framework.TestCase
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.model.TestModule
@@ -58,8 +58,8 @@ internal fun TestConfigurationBuilder.configureForKotlinxSerialization(libraries
                     configuration.addJvmClasspathRoots(librariesPaths)
                 }
 
-                override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
-                    SerializationComponentRegistrar.registerExtensions(project)
+                override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
+                    SerializationComponentRegistrar.registerExtensions(this)
                 }
             }
         })

plugins/lombok/lombok.cli/src/org/jetbrains/kotlin/lombok/LombokPlugin.kt

@@ -5,17 +5,15 @@
 
 package org.jetbrains.kotlin.lombok
 
-import com.intellij.mock.MockProject
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.compiler.plugin.AbstractCliOption
 import org.jetbrains.kotlin.compiler.plugin.CliOption
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.lombok.LombokConfigurationKeys.CONFIG_FILE
 import org.jetbrains.kotlin.lombok.LombokPluginNames.CONFIG_OPTION_NAME
 import org.jetbrains.kotlin.lombok.LombokPluginNames.PLUGIN_ID
@@ -23,26 +21,28 @@ import org.jetbrains.kotlin.lombok.k2.FirLombokRegistrar
 import org.jetbrains.kotlin.resolve.jvm.extensions.SyntheticJavaResolveExtension
 import java.io.File
 
-class LombokComponentRegistrar : ComponentRegistrar {
-
+class LombokComponentRegistrar : CompilerPluginRegistrar() {
     companion object {
-        fun registerComponents(project: Project, compilerConfiguration: CompilerConfiguration) {
+        fun registerComponents(extensionStorage: ExtensionStorage, compilerConfiguration: CompilerConfiguration) = with(extensionStorage) {
             val configFile = compilerConfiguration[CONFIG_FILE]
             val config = LombokPluginConfig(configFile)
-            SyntheticJavaResolveExtension.registerExtension(project, LombokResolveExtension(config))
-            FirExtensionRegistrar.registerExtension(project, FirLombokRegistrar(configFile))
+            SyntheticJavaResolveExtension.registerExtension(LombokResolveExtension(config))
+            FirExtensionRegistrarAdapter.registerExtension(FirLombokRegistrar(configFile))
         }
     }
 
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
             ?.report(
                 CompilerMessageSeverity.WARNING,
                 "Lombok Kotlin compiler plugin is an experimental feature." +
                         " See: https://kotlinlang.org/docs/components-stability.html."
             )
-        registerComponents(project, configuration)
+        registerComponents(this, configuration)
     }
+
+    override val supportsK2: Boolean
+        get() = true
 }
 
 object LombokConfigurationKeys {

plugins/lombok/tests/org/jetbrains/kotlin/lombok/LombokTests.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.lombok
 
-import com.intellij.openapi.project.Project
 import lombok.Getter
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives
@@ -19,7 +19,10 @@ import org.jetbrains.kotlin.test.runners.codegen.AbstractBlackBoxCodegenTest
 import org.jetbrains.kotlin.test.runners.codegen.AbstractFirBlackBoxCodegenTest
 import org.jetbrains.kotlin.test.runners.codegen.AbstractIrBlackBoxCodegenTest
 import org.jetbrains.kotlin.test.runners.configurationForClassicAndFirTestsAlongside
-import org.jetbrains.kotlin.test.services.*
+import org.jetbrains.kotlin.test.services.AdditionalSourceProvider
+import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.sourceFileProvider
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
@@ -99,7 +102,7 @@ class LombokEnvironmentConfigurator(testServices: TestServices) : EnvironmentCon
         }
     }
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
-        LombokComponentRegistrar.registerComponents(project, configuration)
+    override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
+        LombokComponentRegistrar.registerComponents(this, configuration)
     }
 }

plugins/noarg/noarg.cli/src/org/jetbrains/kotlin/noarg/NoArgPlugin.kt

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.noarg
 
-import com.intellij.mock.MockProject
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.compiler.plugin.*
@@ -17,7 +15,7 @@ import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
 import org.jetbrains.kotlin.noarg.NoArgConfigurationKeys.ANNOTATION
 import org.jetbrains.kotlin.noarg.NoArgConfigurationKeys.INVOKE_INITIALIZERS
 import org.jetbrains.kotlin.noarg.NoArgConfigurationKeys.PRESET
@@ -71,28 +69,36 @@ class NoArgCommandLineProcessor : CommandLineProcessor {
     }
 }
 
-class NoArgComponentRegistrar : ComponentRegistrar {
+class NoArgComponentRegistrar : CompilerPluginRegistrar() {
     override val supportsK2: Boolean
         get() = true
 
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         val annotations = configuration.get(ANNOTATION).orEmpty().toMutableList()
         configuration.get(PRESET)?.forEach { preset ->
             SUPPORTED_PRESETS[preset]?.let { annotations += it }
         }
         if (annotations.isNotEmpty()) {
             registerNoArgComponents(
-                project, annotations, configuration.getBoolean(JVMConfigurationKeys.IR), configuration.getBoolean(INVOKE_INITIALIZERS),
+                this,
+                annotations,
+                configuration.getBoolean(JVMConfigurationKeys.IR),
+                configuration.getBoolean(INVOKE_INITIALIZERS),
             )
         }
     }
 
     companion object {
-        fun registerNoArgComponents(project: Project, annotations: List<String>, useIr: Boolean, invokeInitializers: Boolean) {
-            StorageComponentContainerContributor.registerExtension(project, CliNoArgComponentContainerContributor(annotations, useIr))
-            FirExtensionRegistrar.registerExtension(project, FirNoArgExtensionRegistrar(annotations))
-            ExpressionCodegenExtension.registerExtension(project, CliNoArgExpressionCodegenExtension(annotations, invokeInitializers))
-            IrGenerationExtension.registerExtension(project, NoArgIrGenerationExtension(annotations, invokeInitializers))
+        fun registerNoArgComponents(
+            extensionStorage: ExtensionStorage,
+            annotations: List<String>,
+            useIr: Boolean,
+            invokeInitializers: Boolean
+        ) = with(extensionStorage) {
+            StorageComponentContainerContributor.registerExtension(CliNoArgComponentContainerContributor(annotations, useIr))
+            FirExtensionRegistrarAdapter.registerExtension(FirNoArgExtensionRegistrar(annotations))
+            ExpressionCodegenExtension.registerExtension(CliNoArgExpressionCodegenExtension(annotations, invokeInitializers))
+            IrGenerationExtension.registerExtension(NoArgIrGenerationExtension(annotations, invokeInitializers))
         }
     }
 }

plugins/noarg/test/org/jetbrains/kotlin/noarg/NoArgTests.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.noarg
 
-import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
@@ -94,9 +94,12 @@ class NoArgEnvironmentConfigurator(testServices: TestServices) : EnvironmentConf
 
     override val directiveContainers: List<DirectivesContainer> = listOf(NoArgDirectives)
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
+    override fun CompilerPluginRegistrar.ExtensionStorage.registerCompilerExtensions(
+        module: TestModule,
+        configuration: CompilerConfiguration
+    ) {
         NoArgComponentRegistrar.registerNoArgComponents(
-            project,
+            this,
             NOARG_ANNOTATIONS,
             useIr = module.targetBackend?.isIR == true,
             invokeInitializers = NoArgDirectives.INVOKE_INITIALIZERS in module.directives

plugins/parcelize/parcelize-compiler/build.gradle.kts

@@ -37,6 +37,7 @@ dependencies {
     testApi(projectTests(":compiler:test-infrastructure-utils"))
 
     // FIR dependencies
+    testApi(project(":compiler:fir:entrypoint"))
     testApi(project(":compiler:fir:checkers"))
     testApi(project(":compiler:fir:checkers:checkers.jvm"))
     testApi(project(":compiler:fir:checkers:checkers.js"))

plugins/parcelize/parcelize-compiler/parcelize.cli/build.gradle.kts

@@ -12,6 +12,7 @@ dependencies {
     api(project(":plugins:parcelize:parcelize-compiler:parcelize.backend"))
 
     compileOnly(project(":compiler:plugin-api"))
+    compileOnly(project(":compiler:fir:entrypoint"))
     compileOnly(project(":compiler:backend"))
     compileOnly(project(":compiler:ir.backend.common"))
     compileOnly(intellijCore())

plugins/parcelize/parcelize-compiler/parcelize.cli/src/org/jetbrains/kotlin/parcelize/ParcelizeComponentRegistrar.kt

@@ -5,34 +5,35 @@
 
 package org.jetbrains.kotlin.parcelize
 
-import com.intellij.mock.MockProject
-import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
+import org.jetbrains.kotlin.parcelize.fir.FirParcelizeExtensionRegistrar
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension
 
-class ParcelizeComponentRegistrar : ComponentRegistrar {
+class ParcelizeComponentRegistrar : CompilerPluginRegistrar() {
     companion object {
-        fun registerParcelizeComponents(project: Project) {
-            ExpressionCodegenExtension.registerExtension(project, ParcelizeCodegenExtension())
-            IrGenerationExtension.registerExtension(project, ParcelizeIrGeneratorExtension())
-            SyntheticResolveExtension.registerExtension(project, ParcelizeResolveExtension())
-            ClassBuilderInterceptorExtension.registerExtension(project, ParcelizeClinitClassBuilderInterceptorExtension())
-            StorageComponentContainerContributor.registerExtension(project, ParcelizeDeclarationCheckerComponentContainerContributor())
+        fun registerParcelizeComponents(extensionStorage: ExtensionStorage) = with(extensionStorage) {
+            ExpressionCodegenExtension.registerExtension(ParcelizeCodegenExtension())
+            IrGenerationExtension.registerExtension(ParcelizeIrGeneratorExtension())
+            SyntheticResolveExtension.registerExtension(ParcelizeResolveExtension())
+            ClassBuilderInterceptorExtension.registerExtension(ParcelizeClinitClassBuilderInterceptorExtension())
+            StorageComponentContainerContributor.registerExtension(ParcelizeDeclarationCheckerComponentContainerContributor())
+            FirExtensionRegistrarAdapter.registerExtension(FirParcelizeExtensionRegistrar())
         }
     }
 
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
-        registerParcelizeComponents(project)
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
+        registerParcelizeComponents(this)
     }
 
     override val supportsK2: Boolean

plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/runners/AbstractFirParcelizeDiagnosticTest.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.parcelize.test.runners
 
 import org.jetbrains.kotlin.parcelize.test.services.ParcelizeEnvironmentConfigurator
-import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.frontend.fir.FirFailingTestSuppressor
@@ -23,7 +22,7 @@ abstract class AbstractFirParcelizeDiagnosticTest : AbstractKotlinCompilerTest()
             +FirDiagnosticsDirectives.ENABLE_PLUGIN_PHASES
         }
 
-        useConfigurators(::ParcelizeEnvironmentConfigurator.bind(true))
+        useConfigurators(::ParcelizeEnvironmentConfigurator)
 
         useAfterAnalysisCheckers(
             ::FirIdenticalChecker,

plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/runners/AbstractParcelizeBoxTest.kt

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.parcelize.test.runners
 
-import org.jetbrains.kotlin.parcelize.test.services.*
+import org.jetbrains.kotlin.parcelize.test.services.ParcelizeEnvironmentConfigurator
+import org.jetbrains.kotlin.parcelize.test.services.ParcelizeMainClassProvider
+import org.jetbrains.kotlin.parcelize.test.services.ParcelizeRuntimeClasspathProvider
+import org.jetbrains.kotlin.parcelize.test.services.ParcelizeUtilSourcesProvider
 import org.jetbrains.kotlin.test.Constructor
 import org.jetbrains.kotlin.test.TargetBackend
 import org.jetbrains.kotlin.test.backend.BlackBoxCodegenSuppressor
@@ -14,8 +17,10 @@ import org.jetbrains.kotlin.test.backend.classic.ClassicJvmBackendFacade
 import org.jetbrains.kotlin.test.backend.handlers.IrTextDumpHandler
 import org.jetbrains.kotlin.test.backend.ir.IrBackendInput
 import org.jetbrains.kotlin.test.backend.ir.JvmIrBackendFacade
-import org.jetbrains.kotlin.test.bind
-import org.jetbrains.kotlin.test.builders.*
+import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+import org.jetbrains.kotlin.test.builders.configureClassicFrontendHandlersStep
+import org.jetbrains.kotlin.test.builders.configureFirHandlersStep
+import org.jetbrains.kotlin.test.builders.configureIrHandlersStep
 import org.jetbrains.kotlin.test.directives.CodegenTestDirectives.REQUIRES_SEPARATE_PROCESS
 import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.REPORT_ONLY_EXPLICITLY_DEFINED_DEBUG_INFO
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.ENABLE_PLUGIN_PHASES
@@ -71,7 +76,7 @@ abstract class AbstractParcelizeBoxTestBase<R : ResultingArtifact.FrontendOutput
 
         useCustomRuntimeClasspathProviders(::ParcelizeRuntimeClasspathProvider)
 
-        useConfigurators(::ParcelizeEnvironmentConfigurator.bind(targetFrontend == FrontendKinds.FIR))
+        useConfigurators(::ParcelizeEnvironmentConfigurator)
 
         useAdditionalSourceProviders(::ParcelizeUtilSourcesProvider)
 

plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/runners/AbstractParcelizeBytecodeListingTest.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.parcelize.test.runners
 
 import org.jetbrains.kotlin.parcelize.test.services.ParcelizeEnvironmentConfigurator
-import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.AsmLikeInstructionListingDirectives.IR_DIFFERENCE
 import org.jetbrains.kotlin.test.runners.codegen.AbstractAsmLikeInstructionListingTest
@@ -30,5 +29,5 @@ private fun TestConfigurationBuilder.configureParcelizeSpecific() {
     defaultDirectives {
         +IR_DIFFERENCE
     }
-    useConfigurators(::ParcelizeEnvironmentConfigurator.bind(false))
+    useConfigurators(::ParcelizeEnvironmentConfigurator)
 }

plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/runners/AbstractParcelizeDiagnosticTest.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.parcelize.test.runners
 
 import org.jetbrains.kotlin.parcelize.test.services.ParcelizeEnvironmentConfigurator
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.classicFrontendHandlersStep
 import org.jetbrains.kotlin.test.builders.classicFrontendStep
@@ -41,7 +40,7 @@ abstract class AbstractParcelizeDiagnosticTest : AbstractKotlinCompilerTest() {
         useConfigurators(
             ::CommonEnvironmentConfigurator,
             ::JvmEnvironmentConfigurator,
-            ::ParcelizeEnvironmentConfigurator.bind(false)
+            ::ParcelizeEnvironmentConfigurator
         )
 
         classicFrontendStep()

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

@@ -5,14 +5,10 @@
 
 package org.jetbrains.kotlin.parcelize.test.services
 
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.parcelize.ParcelizeComponentRegistrar
-import org.jetbrains.kotlin.parcelize.ParcelizeFirIrGeneratorExtension
-import org.jetbrains.kotlin.parcelize.fir.FirParcelizeExtensionRegistrar
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.EnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.TestServices
@@ -20,10 +16,7 @@ import org.jetbrains.kotlin.test.util.KtTestUtil
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
-class ParcelizeEnvironmentConfigurator(
-    testServices: TestServices,
-    private val useFirExtension: Boolean
-) : EnvironmentConfigurator(testServices) {
+class ParcelizeEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
     override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) {
         val runtimeLibrary = File(PathUtil.kotlinPathsForCompiler.libPath, PathUtil.PARCELIZE_RUNTIME_PLUGIN_JAR_NAME)
         val androidExtensionsRuntimeLibrary = File(PathUtil.kotlinPathsForCompiler.libPath, PathUtil.ANDROID_EXTENSIONS_RUNTIME_PLUGIN_JAR_NAME)
@@ -31,12 +24,10 @@ class ParcelizeEnvironmentConfigurator(
         configuration.addJvmClasspathRoots(listOf(runtimeLibrary, androidExtensionsRuntimeLibrary, androidApiJar))
     }
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
-        if (useFirExtension) {
-            FirExtensionRegistrar.registerExtension(project, FirParcelizeExtensionRegistrar())
-            IrGenerationExtension.registerExtension(project, ParcelizeFirIrGeneratorExtension())
-        } else {
-            ParcelizeComponentRegistrar.registerParcelizeComponents(project)
-        }
+    override fun CompilerPluginRegistrar.ExtensionStorage.registerCompilerExtensions(
+        module: TestModule,
+        configuration: CompilerConfiguration
+    ) {
+        ParcelizeComponentRegistrar.registerParcelizeComponents(this)
     }
 }

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

@@ -17,7 +17,7 @@ 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, module: TestModule, configuration: CompilerConfiguration) {
+    override fun legacyRegisterCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
         SyntheticResolveExtension.registerExtension(project, SerializableLike())
     }
 

plugins/sam-with-receiver/sam-with-receiver.cli/resources/META-INF/services/org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar

@@ -0,0 +1 @@
+org.jetbrains.kotlin.samWithReceiver.SamWithReceiverComponentRegistrar

plugins/sam-with-receiver/sam-with-receiver.cli/src/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverPlugin.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.samWithReceiver
 
-import com.intellij.mock.MockProject
 import org.jetbrains.kotlin.compiler.plugin.*
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
@@ -53,17 +52,20 @@ class SamWithReceiverCommandLineProcessor : CommandLineProcessor {
     }
 }
 
-class SamWithReceiverComponentRegistrar : ComponentRegistrar {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+class SamWithReceiverComponentRegistrar : CompilerPluginRegistrar() {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         val annotations = configuration.get(ANNOTATION)?.toMutableList() ?: mutableListOf()
         configuration.get(PRESET)?.forEach { preset ->
             SUPPORTED_PRESETS[preset]?.let { annotations += it }
         }
         if (annotations.isEmpty()) return
 
-        StorageComponentContainerContributor.registerExtension(project, CliSamWithReceiverComponentContributor(annotations))
-        FirExtensionRegistrarAdapter.registerExtension(project, FirSamWithReceiverExtensionRegistrar(annotations))
+        StorageComponentContainerContributor.registerExtension(CliSamWithReceiverComponentContributor(annotations))
+        FirExtensionRegistrarAdapter.registerExtension(FirSamWithReceiverExtensionRegistrar(annotations))
     }
+
+    override val supportsK2: Boolean
+        get() = true
 }
 
 class CliSamWithReceiverComponentContributor(val annotations: List<String>) : StorageComponentContainerContributor {

plugins/sam-with-receiver/test/org/jetbrains/kotlin/samWithReceiver/AbstractSamWithReceiverScriptNewDefTest.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.samWithReceiver
 
-import com.intellij.mock.MockProject
 import org.jetbrains.kotlin.ObsoleteTestInfrastructure
 import org.jetbrains.kotlin.TestsCompilerError
 import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.compiler.plugin.registerExtensionsForTest
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.ScriptJvmCompilerFromEnvironment
 import org.jetbrains.kotlin.scripting.configuration.ScriptingConfigurationKeys
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinition
@@ -38,7 +38,9 @@ abstract class AbstractSamWithReceiverScriptNewDefTest : AbstractDiagnosticsTest
         val scriptCompiler = ScriptJvmCompilerFromEnvironment(environment)
         val res = scriptCompiler.compile("42".toScriptSource("\$init"), ScriptForSamWithReceiversNewDefCompilationConfiguration)
         Assert.assertTrue(res is ResultWithDiagnostics.Success<*>)
-        SamWithReceiverComponentRegistrar().registerProjectComponents(environment.project as MockProject, environment.configuration)
+        registerExtensionsForTest(environment.project, environment.configuration) {
+            with(SamWithReceiverComponentRegistrar()) { registerExtensions(it) }
+        }
     }
 
     override fun analyzeAndCheck(testDataFile: File, files: List<TestFile>) {

plugins/sam-with-receiver/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverTests.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.samWithReceiver
 
-import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrarAdapter
@@ -60,12 +60,11 @@ class SamWithReceiverEnvironmentConfigurator(testServices: TestServices) : Envir
         private val TEST_ANNOTATIONS = listOf("SamWithReceiver")
     }
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
-        StorageComponentContainerContributor.registerExtension(
-            project,
-            CliSamWithReceiverComponentContributor(TEST_ANNOTATIONS)
-        )
-
-        FirExtensionRegistrarAdapter.registerExtension(project, FirSamWithReceiverExtensionRegistrar(TEST_ANNOTATIONS))
+    override fun ExtensionStorage.registerCompilerExtensions(
+        module: TestModule,
+        configuration: CompilerConfiguration
+    ) {
+        StorageComponentContainerContributor.registerExtension(CliSamWithReceiverComponentContributor(TEST_ANNOTATIONS))
+        FirExtensionRegistrarAdapter.registerExtension(FirSamWithReceiverExtensionRegistrar(TEST_ANNOTATIONS))
     }
 }

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/loadCompilerPlugins.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.jvm.plugins.processCompilerPluginsOptions
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptingCommandLineProcessor
 import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptingCompilerConfigurationComponentRegistrar
@@ -32,6 +33,10 @@ internal fun CompilerConfiguration.loadPlugins() {
     val registrars =
         classLoader.loadServices<ComponentRegistrar>(scriptCompilationDisabledPlugins, SCRIPT_COMPILATION_DISABLE_PLUGINS_PROPERTY)
     addAll(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, registrars)
+    val k2Registrars =
+        classLoader.loadServices<CompilerPluginRegistrar>(scriptCompilationDisabledPlugins, SCRIPT_COMPILATION_DISABLE_PLUGINS_PROPERTY)
+    addAll(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS, k2Registrars)
+
 }
 
 internal fun CompilerConfiguration.processPluginsCommandLine(arguments: K2JVMCompilerArguments) {