[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

.idea/encodings.xml

@@ -4,21 +4,59 @@
     <file url="file://$PROJECT_DIR$/libraries" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/examples/browser-example" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/examples/browser-example-with-library" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example-with-library/src/main/kotlin" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example-with-library/src/main/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example/src/main/kotlin" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/browser-example/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/examples/js-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/js-example/src/main/kotlin" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/js-example/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-java-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-java-example/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-java-example/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-js-library-example" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-js-library-example/src/main/kotlin" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/examples/kotlin-js-library-example/src/main/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/idl2k" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-annotation-processing-maven" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-annotation-processing-maven/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-dist-for-jps-meta/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-dist-for-jps-meta/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-allopen" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-allopen/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-lombok/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-noarg" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-noarg/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin-test" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin-test/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin-test/src/test/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-plugin/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-sam-with-receiver" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-sam-with-receiver/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-serialization" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-maven-serialization/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-osgi-bundle" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-osgi-bundle/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/kotlin-osgi-bundle/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-js" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-js/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-js/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-jvm" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-jvm/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/kotlin-archetype-jvm/src/main/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/libraries/tools/maven-archetypes/src/main/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/plugins/allopen/allopen.cli/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/plugins/kapt3/kapt3-compiler/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/plugins/kotlin-serialization/kotlin-serialization-compiler/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/plugins/lombok/lombok.cli/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/plugins/noarg/noarg.cli/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/plugins/sam-with-receiver/sam-with-receiver.cli/resources" charset="UTF-8" />
     <file url="PROJECT" charset="UTF-8" />
   </component>
 </project>

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/compilerPluginConfiguration.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.fir.utils
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.AnalysisFlag
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersion
@@ -58,9 +59,20 @@ private class EnabledByDirectiveConfiguratorDecorator(
         languageVersion: LanguageVersion
     ): Map<AnalysisFlag<*>, Any?> = original.provideAdditionalAnalysisFlags(directives, languageVersion)
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
+    override fun legacyRegisterCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
         if (directive !in module.directives) return
 
-        original.registerCompilerExtensions(project, module, configuration)
+        original.legacyRegisterCompilerExtensions(project, module, configuration)
+    }
+
+    override fun CompilerPluginRegistrar.ExtensionStorage.registerCompilerExtensions(
+        module: TestModule,
+        configuration: CompilerConfiguration
+    ) {
+        if (directive !in module.directives) return
+
+        with(original) {
+            this@registerCompilerExtensions.registerCompilerExtensions(module, configuration)
+        }
     }
 }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/compilerPluginConfiguration.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.test.base
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.AnalysisFlag
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersion
@@ -58,9 +59,20 @@ private class EnabledByDirectiveConfiguratorDecorator(
         languageVersion: LanguageVersion
     ): Map<AnalysisFlag<*>, Any?> = original.provideAdditionalAnalysisFlags(directives, languageVersion)
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
+    override fun legacyRegisterCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
         if (directive !in module.directives) return
 
-        original.registerCompilerExtensions(project, module, configuration)
+        original.legacyRegisterCompilerExtensions(project, module, configuration)
     }
-}
+
+    override fun CompilerPluginRegistrar.ExtensionStorage.registerCompilerExtensions(
+        module: TestModule,
+        configuration: CompilerConfiguration
+    ) {
+        if (directive !in module.directives) return
+
+        with(original) {
+            this@registerCompilerExtensions.registerCompilerExtensions(module, configuration)
+        }
+    }
+}

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector
@@ -87,21 +88,21 @@ object FirKotlinToJvmBytecodeCompiler {
             "ATTENTION!\n This build uses experimental K2 compiler: \n  -Xuse-k2"
         )
 
-        projectConfiguration.get(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)?.let { pluginComponentRegistrars ->
+        val notSupportedPlugins = mutableListOf<String?>().apply {
-            val notSupportedPlugins = pluginComponentRegistrars.filter {
+            projectConfiguration.get(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS).collectIncompatiblePluginNamesTo(this, ComponentRegistrar::supportsK2)
-                !it.supportsK2 && it::class.java.canonicalName != CLICompiler.SCRIPT_PLUGIN_REGISTRAR_NAME
+            projectConfiguration.get(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS).collectIncompatiblePluginNamesTo(this, CompilerPluginRegistrar::supportsK2)
-            }
+        }
-            if (notSupportedPlugins.isNotEmpty()) {
+
-                messageCollector.report(
+        if (notSupportedPlugins.isNotEmpty()) {
-                    CompilerMessageSeverity.ERROR,
+            messageCollector.report(
-                    """
+                CompilerMessageSeverity.ERROR,
-                        |There are some plugins incompatible with K2 compiler:
+                """
-                        |${notSupportedPlugins.joinToString(separator = "\n|") { "  ${it::class.qualifiedName}" }}
+                    |There are some plugins incompatible with K2 compiler:
-                        |Please remove -Xuse-k2
+                    |${notSupportedPlugins.joinToString(separator = "\n|") { "  $it" }}
-                    """.trimMargin()
+                    |Please remove -Xuse-k2
-                )
+                """.trimMargin()
-                return false
+            )
-            }
+            return false
         }
         if (projectConfiguration.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)) {
             messageCollector.report(
@@ -153,6 +154,14 @@ object FirKotlinToJvmBytecodeCompiler {
         )
     }
 
+    private fun <T : Any> List<T>?.collectIncompatiblePluginNamesTo(
+        destination: MutableList<String?>,
+        supportsK2: T.() -> Boolean
+    ) {
+        this?.filter { !it.supportsK2() && it::class.java.canonicalName != CLICompiler.SCRIPT_PLUGIN_REGISTRAR_NAME }
+            ?.mapTo(destination) { it::class.qualifiedName }
+    }
+
     private fun CompilationContext.compileModule(): Pair<FirResult, GenerationState>? {
         performanceManager?.notifyAnalysisStarted()
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()

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

@@ -62,6 +62,8 @@ import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.codegen.extensions.ClassFileFactoryFinalizerExtension
 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.compiler.plugin.registerInProject
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.extensions.*
 import org.jetbrains.kotlin.extensions.internal.CandidateInterceptor
@@ -637,12 +639,17 @@ class KotlinCoreEnvironment private constructor(
         }
 
         internal fun registerExtensionsFromPlugins(project: MockProject, configuration: CompilerConfiguration) {
+            fun createErrorMessage(extension: Any): String {
+                return "The provided plugin ${extension.javaClass.name} is not compatible with this version of compiler"
+            }
+
             val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+
             for (registrar in configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
                 try {
                     registrar.registerProjectComponents(project, configuration)
                 } catch (e: AbstractMethodError) {
-                    val message = "The provided plugin ${registrar.javaClass.name} is not compatible with this version of compiler"
+                    val message = createErrorMessage(registrar)
                     // Since the scripting plugin is often discovered in the compiler environment, it is often taken from the incompatible
                     // location, and in many cases this is not a fatal error, therefore strong warning is generated instead of exception
                     if (registrar.javaClass.simpleName == "ScriptingCompilerConfigurationComponentRegistrar") {
@@ -652,8 +659,13 @@ class KotlinCoreEnvironment private constructor(
                     }
                 }
             }
-        }
 
+            val extensionStorage = CompilerPluginRegistrar.ExtensionStorage()
+            for (registrar in configuration.getList(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS)) {
+                with(registrar) { extensionStorage.registerExtensions(configuration) }
+            }
+            extensionStorage.registerInProject(project) { createErrorMessage(it) }
+        }
 
         private fun registerApplicationServicesForCLI(applicationEnvironment: KotlinCoreApplicationEnvironment) {
             // ability to get text from annotations xml files

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/plugins/PluginCliParser.kt

@@ -69,6 +69,9 @@ object PluginCliParser {
         val componentRegistrars = ServiceLoaderLite.loadImplementations(ComponentRegistrar::class.java, classLoader)
         configuration.addAll(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, componentRegistrars)
 
+        val compilerPluginRegistrars = ServiceLoaderLite.loadImplementations(CompilerPluginRegistrar::class.java, classLoader)
+        configuration.addAll(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS, compilerPluginRegistrars)
+
         processPluginOptions(pluginOptions, configuration, classLoader)
     }
 

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.plugins.ServiceLoaderLite
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.daemon.common.CompileService
 import org.jetbrains.kotlin.daemon.common.CompilerId
@@ -207,13 +208,12 @@ inline fun getValidId(counter: AtomicInteger, check: (Int) -> Boolean): Int {
 
 fun CompilerConfiguration.configureScripting(compilerId: CompilerId) {
     val error = try {
-        val componentRegistrars =
+        val componentRegistrars = loadRegistrars<ComponentRegistrar>(compilerId)
-            (this::class.java.classLoader as? URLClassLoader)?.let {
-                ServiceLoaderLite.loadImplementations(ComponentRegistrar::class.java, it)
-            } ?: ServiceLoaderLite.loadImplementations(
-                ComponentRegistrar::class.java, compilerId.compilerClasspath.map(::File), this::class.java.classLoader
-            )
         addAll(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, componentRegistrars)
+
+        val compilerPluginRegistrars = loadRegistrars<CompilerPluginRegistrar>(compilerId)
+        addAll(CompilerPluginRegistrar.COMPILER_PLUGIN_REGISTRARS, compilerPluginRegistrars)
+
         null
     } catch (e: NoClassDefFoundError) {
         e
@@ -227,3 +227,11 @@ fun CompilerConfiguration.configureScripting(compilerId: CompilerId) {
         )
     }
 }
+
+private inline fun <reified T : Any> CompilerConfiguration.loadRegistrars(compilerId: CompilerId): List<T> {
+    return (this::class.java.classLoader as? URLClassLoader)?.let {
+        ServiceLoaderLite.loadImplementations(T::class.java, it)
+    } ?: ServiceLoaderLite.loadImplementations(
+        T::class.java, compilerId.compilerClasspath.map(::File), this::class.java.classLoader
+    )
+}

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/extensions/FirExtensionRegistrar.kt

@@ -20,10 +20,6 @@ abstract class FirExtensionRegistrar : FirExtensionRegistrarAdapter() {
             return FirExtensionRegistrarAdapter.getInstances(project) as List<FirExtensionRegistrar>
         }
 
-        fun registerExtension(project: Project, extension: FirExtensionRegistrar) {
-            FirExtensionRegistrarAdapter.registerExtension(project, extension)
-        }
-
         internal val AVAILABLE_EXTENSIONS = listOf(
             FirStatusTransformerExtension::class,
             FirDeclarationGenerationExtension::class,

compiler/plugin-api/src/org/jetbrains/kotlin/compiler/plugin/CompilerPluginRegistrar.kt

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.compiler.plugin
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.CompilerConfigurationKey
+import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
+
+abstract class CompilerPluginRegistrar {
+    companion object {
+        val COMPILER_PLUGIN_REGISTRARS: CompilerConfigurationKey<MutableList<CompilerPluginRegistrar>> =
+            CompilerConfigurationKey.create("Compiler plugin registrars")
+    }
+
+    abstract fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration)
+
+    class ExtensionStorage {
+        private val _registeredExtensions = mutableMapOf<ProjectExtensionDescriptor<*>, MutableList<Any>>()
+        val registeredExtensions: Map<ProjectExtensionDescriptor<*>, List<Any>>
+            get() = _registeredExtensions
+
+        fun <T : Any> ProjectExtensionDescriptor<T>.registerExtension(extension: T) {
+            _registeredExtensions.getOrPut(this, ::mutableListOf).add(extension)
+        }
+    }
+
+    abstract val supportsK2: Boolean
+}
+
+fun CompilerPluginRegistrar.ExtensionStorage.registerInProject(
+    project: Project,
+    errorMessage: (Any) -> String = { "Error while registering ${it.javaClass.name} "}
+) {
+    for ((extensionPoint, extensions) in registeredExtensions) {
+        for (extension in extensions) {
+            @Suppress("UNCHECKED_CAST")
+            try {
+                (extensionPoint as ProjectExtensionDescriptor<Any>).registerExtensionUnsafe(project, extension)
+            } catch (e: AbstractMethodError) {
+                throw IllegalStateException(errorMessage(extension), e)
+            }
+        }
+    }
+}
+
+private fun ProjectExtensionDescriptor<Any>.registerExtensionUnsafe(project: Project, extension: Any) {
+    this.registerExtension(project, extension)
+}
+
+@TestOnly
+fun registerExtensionsForTest(
+    project: Project,
+    configuration: CompilerConfiguration,
+    register: CompilerPluginRegistrar.ExtensionStorage.(CompilerConfiguration) -> Unit
+) {
+    val extensionStorage = CompilerPluginRegistrar.ExtensionStorage().apply {
+        register(configuration)
+    }
+    extensionStorage.registerInProject(project)
+}

compiler/plugin-api/src/org/jetbrains/kotlin/compiler/plugin/ComponentRegistrar.kt

@@ -17,8 +17,8 @@
 package org.jetbrains.kotlin.compiler.plugin
 
 import com.intellij.mock.MockProject
-import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.CompilerConfigurationKey
 
 interface ComponentRegistrar {
     companion object {

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.test.services
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar.ExtensionStorage
 import org.jetbrains.kotlin.config.AnalysisFlag
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
@@ -22,7 +23,8 @@ abstract class AbstractEnvironmentConfigurator : ServicesAndDirectivesContainer
 
     abstract fun provideAdditionalAnalysisFlags(directives: RegisteredDirectives, languageVersion: LanguageVersion): Map<AnalysisFlag<*>, Any?>
 
-    abstract fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration)
+    abstract fun legacyRegisterCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration)
+    abstract fun ExtensionStorage.registerCompilerExtensions( module: TestModule, configuration: CompilerConfiguration)
 }
 
 class EnvironmentConfiguratorsProvider(internal val environmentConfigurators: List<AbstractEnvironmentConfigurator>) : TestService
@@ -56,7 +58,9 @@ abstract class EnvironmentConfigurator(protected val testServices: TestServices)
         return emptyMap()
     }
 
-    override fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {}
+    override fun legacyRegisterCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {}
+
+    override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {}
 }
 
 class DirectiveToConfigurationKeyExtractor {

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

@@ -15,6 +15,8 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.compiler.plugin.registerInProject
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
@@ -44,7 +46,14 @@ abstract class CompilerConfigurationProvider(val testServices: TestServices) : T
     }
 
     fun registerCompilerExtensions(project: Project, module: TestModule, configuration: CompilerConfiguration) {
-        configurators.forEach { it.registerCompilerExtensions(project, module, configuration) }
+        val extensionStorage = CompilerPluginRegistrar.ExtensionStorage()
+        for (configurator in configurators) {
+            configurator.legacyRegisterCompilerExtensions(project, module, configuration)
+            with(configurator) {
+                extensionStorage.registerCompilerExtensions(module, configuration)
+            }
+        }
+        extensionStorage.registerInProject(project)
     }
 
     open fun getPackagePartProviderFactory(module: TestModule): (GlobalSearchScope) -> JvmPackagePartProvider {

libraries/tools/kotlin-maven-plugin-test/src/it/test-plugins/test-extension/src/main/kotlin/org/jetbrains/kotlin/test/TestKotlinPluginRegistrar.kt

@@ -30,12 +30,15 @@ class TestCommandLineProcessor : CommandLineProcessor {
     }
 }
 
-class TestKotlinPluginRegistrar : ComponentRegistrar {
+class TestKotlinPluginRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
         val collector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)!!
         val option = configuration.get(TestPluginKeys.TestOption)!!
 
         collector.report(CompilerMessageSeverity.INFO, "Plugin applied")
         collector.report(CompilerMessageSeverity.INFO, "Option value: $option")
     }
+
+    override val supportsK2: Boolean
+        get() = true
 }

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 {
+class AllOpenComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    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))
+        DeclarationAttributeAltererExtension.registerExtension(CliAllOpenDeclarationAttributeAltererExtension(annotations))
-        FirExtensionRegistrar.registerExtension(project, FirAllOpenExtensionRegistrar(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(
+        DeclarationAttributeAltererExtension.registerExtension(CliAllOpenDeclarationAttributeAltererExtension(annotations))
-            project,
+        FirExtensionRegistrarAdapter.registerExtension(FirAllOpenExtensionRegistrar(annotations))
-            CliAllOpenDeclarationAttributeAltererExtension(annotations)
-        )
-
-        FirExtensionRegistrar.registerExtension(project, 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 {
+class AtomicfuComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
-        registerExtensions(project)
+        Companion.registerExtensions(this)
     }
 
     override val supportsK2: Boolean
         get() = true
 
     companion object {
-        fun registerExtensions(project: Project) {
+        fun registerExtensions(extensionStorage: ExtensionStorage) = with(extensionStorage) {
-            IrGenerationExtension.registerExtension(project, AtomicfuLoweringExtension()) }
+            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) {
+                override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
-                    AtomicfuComponentRegistrar.registerExtensions(project)
+                    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 {
+class FirPluginPrototypeComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override val supportsK2: Boolean
-        FirExtensionRegistrar.registerExtension(project, FirPluginPrototypeExtensionRegistrar())
+        get() = true
-        IrGenerationExtension.registerExtension(project, GeneratedDeclarationsIrBodyFiller())
+
+    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) {
+    override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
-        FirExtensionRegistrar.registerExtension(project, FirPluginPrototypeExtensionRegistrar())
+        FirExtensionRegistrarAdapter.registerExtension(FirPluginPrototypeExtensionRegistrar())
-        IrGenerationExtension.registerExtension(project, GeneratedDeclarationsIrBodyFiller())
+        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.CompilerPluginRegistrar
-import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 
-class ImportsDumperComponentRegistrar : ComponentRegistrar {
+class ImportsDumperComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    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 {
+class JvmAbiComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    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)
+            ClassBuilderInterceptorExtension.registerExtension( builderExtension)
-            ClassFileFactoryFinalizerExtension.registerExtension(project, outputExtension)
+            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 {
+class SerializationComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
-        registerExtensions(project)
+        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))
+            ExpressionCodegenExtension.registerExtension(SerializationCodegenExtension(serializationDescriptorSerializer))
-            JsSyntheticTranslateExtension.registerExtension(project, SerializationJsExtension(serializationDescriptorSerializer))
+            JsSyntheticTranslateExtension.registerExtension(SerializationJsExtension(serializationDescriptorSerializer))
-            IrGenerationExtension.registerExtension(project, SerializationLoweringExtension(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) {
+                override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
-                    SerializationComponentRegistrar.registerExtensions(project)
+                    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))
+            SyntheticJavaResolveExtension.registerExtension(LombokResolveExtension(config))
-            FirExtensionRegistrar.registerExtension(project, FirLombokRegistrar(configFile))
+            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) {
+    override fun ExtensionStorage.registerCompilerExtensions(module: TestModule, configuration: CompilerConfiguration) {
-        LombokComponentRegistrar.registerComponents(project, configuration)
+        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) {
+        fun registerNoArgComponents(
-            StorageComponentContainerContributor.registerExtension(project, CliNoArgComponentContainerContributor(annotations, useIr))
+            extensionStorage: ExtensionStorage,
-            FirExtensionRegistrar.registerExtension(project, FirNoArgExtensionRegistrar(annotations))
+            annotations: List<String>,
-            ExpressionCodegenExtension.registerExtension(project, CliNoArgExpressionCodegenExtension(annotations, invokeInitializers))
+            useIr: Boolean,
-            IrGenerationExtension.registerExtension(project, NoArgIrGenerationExtension(annotations, invokeInitializers))
+            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) {
+        fun registerParcelizeComponents(extensionStorage: ExtensionStorage) = with(extensionStorage) {
-            ExpressionCodegenExtension.registerExtension(project, ParcelizeCodegenExtension())
+            ExpressionCodegenExtension.registerExtension(ParcelizeCodegenExtension())
-            IrGenerationExtension.registerExtension(project, ParcelizeIrGeneratorExtension())
+            IrGenerationExtension.registerExtension(ParcelizeIrGeneratorExtension())
-            SyntheticResolveExtension.registerExtension(project, ParcelizeResolveExtension())
+            SyntheticResolveExtension.registerExtension(ParcelizeResolveExtension())
-            ClassBuilderInterceptorExtension.registerExtension(project, ParcelizeClinitClassBuilderInterceptorExtension())
+            ClassBuilderInterceptorExtension.registerExtension(ParcelizeClinitClassBuilderInterceptorExtension())
-            StorageComponentContainerContributor.registerExtension(project, ParcelizeDeclarationCheckerComponentContainerContributor())
+            StorageComponentContainerContributor.registerExtension(ParcelizeDeclarationCheckerComponentContainerContributor())
+            FirExtensionRegistrarAdapter.registerExtension(FirParcelizeExtensionRegistrar())
         }
     }
 
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    override fun ExtensionStorage.registerExtensions(configuration: CompilerConfiguration) {
-        registerParcelizeComponents(project)
+        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.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.builders.*
+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(
+class ParcelizeEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) {
-    testServices: TestServices,
-    private val useFirExtension: Boolean
-) : 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) {
+    override fun CompilerPluginRegistrar.ExtensionStorage.registerCompilerExtensions(
-        if (useFirExtension) {
+        module: TestModule,
-            FirExtensionRegistrar.registerExtension(project, FirParcelizeExtensionRegistrar())
+        configuration: CompilerConfiguration
-            IrGenerationExtension.registerExtension(project, ParcelizeFirIrGeneratorExtension())
+    ) {
-        } else {
+        ParcelizeComponentRegistrar.registerParcelizeComponents(this)
-            ParcelizeComponentRegistrar.registerParcelizeComponents(project)
-        }
     }
 }

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 {
+class SamWithReceiverComponentRegistrar : CompilerPluginRegistrar() {
-    override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
+    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))
+        StorageComponentContainerContributor.registerExtension(CliSamWithReceiverComponentContributor(annotations))
-        FirExtensionRegistrarAdapter.registerExtension(project, FirSamWithReceiverExtensionRegistrar(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) {
+    override fun ExtensionStorage.registerCompilerExtensions(
-        StorageComponentContainerContributor.registerExtension(
+        module: TestModule,
-            project,
+        configuration: CompilerConfiguration
-            CliSamWithReceiverComponentContributor(TEST_ANNOTATIONS)
+    ) {
-        )
+        StorageComponentContainerContributor.registerExtension(CliSamWithReceiverComponentContributor(TEST_ANNOTATIONS))
-
+        FirExtensionRegistrarAdapter.registerExtension(FirSamWithReceiverExtensionRegistrar(TEST_ANNOTATIONS))
-        FirExtensionRegistrarAdapter.registerExtension(project, 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) {