[kotlin] Update the CompilerConfiguration creation

The default way of creating `CompilerConfiguration` is using
the `CompilerConfiguration.create()` utility instead of constructor.
This utility automatically registers all default services, so their manual
registration is also removed.

Also, replace all usages of `CompilerConfiguration.EMPTY` with creation
of the new empty configuration.

GitOrigin-RevId: 48b5b51d9dbc5121d8c1af0d44aecbc760542ef6

plugins/kotlin/fir/src/org/jetbrains/kotlin/idea/fir/extensions/KtCompilerPluginsCache.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.analysis.api.projectStructure.KaSourceModule
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirInternals
 import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.extensionsStorage
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.cli.plugins.processCompilerPluginsOptions
 import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
 import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.scripting.definitions.findScriptDefinition
 import org.jetbrains.kotlin.util.ServiceLoaderLite
 import java.io.File
 import java.nio.file.Path
-import java.util.Optional
+import java.util.*
 import java.util.concurrent.ConcurrentMap
 import kotlin.script.experimental.api.ScriptCompilationConfiguration
 import kotlin.script.experimental.api.compilerOptions
@@ -166,9 +166,8 @@ class KtCompilerPluginsCache private constructor(
         ProgressManager.checkCanceled()
 
         val compilerConfiguration =
-            CompilerConfiguration().apply {
+            CompilerConfiguration.create().apply {
                 @OptIn(ExperimentalCompilerApi::class)
-                extensionsStorage = CompilerPluginRegistrar.ExtensionStorage()
                 // Temporary work-around for KTIJ-24320. Calls to 'setupCommonArguments()' and 'setupJvmSpecificArguments()'
                 // (or even a platform-agnostic alternative) should be added.
                 if (compilerArguments is K2JVMCompilerArguments && module is KaSourceModule) {

plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractLoadJavaClsStubTest.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinDecompiledFileViewProv
 import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtClsFile
 import org.jetbrains.kotlin.analysis.decompiler.stub.file.KotlinClsStubBuilder
 import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory
-import org.jetbrains.kotlin.cli.pipeline.registerExtensionStorage
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
@@ -35,10 +35,9 @@ abstract class AbstractLoadJavaClsStubTest : KotlinLightCodeInsightFixtureTestCa
         val ktFile = myFixture.file as KtFile
         val analysisResult = ktFile.analyzeWithAllCompilerChecks()
 
-        val configuration = CompilerConfiguration().apply {
+        val configuration = CompilerConfiguration.create().apply {
             languageVersionSettings = file.languageVersionSettings
             put(JVMConfigurationKeys.DO_NOT_CLEAR_BINDING_CONTEXT, true)
-            registerExtensionStorage()
         }
 
         val state = GenerationState(project, analysisResult.moduleDescriptor, configuration)

plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowMultiplatformTest.kt

@@ -5,9 +5,7 @@ import com.intellij.openapi.application.readAction
 import com.intellij.openapi.progress.runBlockingMaybeCancellable
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
-import org.jetbrains.kotlin.cli.extensionsStorage
-import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
-import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.idea.base.projectStructure.languageVersionSettings
@@ -35,10 +33,8 @@ abstract class AbstractBytecodeToolWindowMultiplatformTest : AbstractMultiModule
 }
 
 private fun configureCompilerAndCheckBytecode(file: KtFile) {
-    val configuration = CompilerConfiguration().apply {
+    val configuration = CompilerConfiguration.create().apply {
         languageVersionSettings = file.languageVersionSettings
-        @OptIn(ExperimentalCompilerApi::class)
-        extensionsStorage = CompilerPluginRegistrar.ExtensionStorage()
     }
 
     val bytecode = runBlockingMaybeCancellable {

plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/idea/test/KotlinTestUtilsImpl.java

@@ -5,7 +5,7 @@ import com.intellij.openapi.Disposable;
 import com.intellij.testFramework.IdeaTestUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.cli.FrontendConfigurationKeys;
+import org.jetbrains.kotlin.cli.CompilerConfigurationCreationKt;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation;
@@ -13,8 +13,6 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
-import org.jetbrains.kotlin.cli.pipeline.AbstractConfigurationPhaseKt;
-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;
@@ -49,9 +47,8 @@ public final class KotlinTestUtilsImpl {
 
     @NotNull
     public static CompilerConfiguration newConfiguration() {
-        CompilerConfiguration configuration = new CompilerConfiguration();
+        CompilerConfiguration configuration = CompilerConfigurationCreationKt.create(CompilerConfiguration.Companion);
         configuration.put(CommonConfigurationKeys.MODULE_NAME, TEST_MODULE_NAME);
-        configuration.put(FrontendConfigurationKeys.EXTENSIONS_STORAGE, new CompilerPluginRegistrar.ExtensionStorage());
 
         configuration.put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, new MessageCollector() {
             @Override
@@ -114,7 +111,6 @@ public final class KotlinTestUtilsImpl {
         );
 
         setupIdeaStandaloneExecution();
-        AbstractConfigurationPhaseKt.registerExtensionStorage(configuration);
 
         return configuration;
     }

plugins/kotlin/intellij.kotlin.base.test/test/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt

@@ -4,6 +4,7 @@ package org.jetbrains.kotlin.idea.internal
 import com.intellij.openapi.application.readAction
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.cli.extensionsStorage
 import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
@@ -37,14 +38,12 @@ abstract class AbstractBytecodeToolWindowTest : KotlinLightCodeInsightFixtureTes
 
         val file = myFixture.file as KtFile
 
-        val configuration = CompilerConfiguration().apply {
+        val configuration = CompilerConfiguration.create().apply {
             if (InTextDirectivesUtils.getPrefixedBoolean(mainFileText, "// INLINE:") == false) {
                 put(CommonConfigurationKeys.DISABLE_INLINE, true)
             }
 
             languageVersionSettings = file.languageVersionSettings
-            @OptIn(ExperimentalCompilerApi::class)
-            extensionsStorage = CompilerPluginRegistrar.ExtensionStorage()
         }
 
         val bytecode = runBlocking(Dispatchers.Default) {

plugins/kotlin/jvm-debugger/evaluation/k1/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilation/CodeFragmentCompiler.kt

@@ -6,9 +6,9 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import org.jetbrains.kotlin.K1Deprecation
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.cli.extensionsStorage
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
 import org.jetbrains.kotlin.compiler.plugin.registerInProject
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -109,14 +109,12 @@ class CodeFragmentCompiler(private val executionContext: ExecutionContext) {
 
         val fragmentCompilerBackend = IRFragmentCompilerCodegen()
 
-        @OptIn(ExperimentalCompilerApi::class)
-        val extensionStorage = CompilerPluginRegistrar.ExtensionStorage()
-        val compilerConfiguration = CompilerConfiguration().apply {
+        val compilerConfiguration = CompilerConfiguration.create().apply {
             languageVersionSettings = codeFragment.languageVersionSettings
             doNotClearBindingContext = true
-            @OptIn(ExperimentalCompilerApi::class)
-            extensionsStorage = extensionStorage
         }
+        @OptIn(ExperimentalCompilerApi::class)
+        val extensionStorage = compilerConfiguration.extensionsStorage!!
 
         val parameterInfo = fragmentCompilerBackend.computeFragmentParameters(executionContext, codeFragment, bindingContext)
 

plugins/kotlin/jvm-debugger/evaluation/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentCompiler.kt

@@ -26,8 +26,7 @@ import org.jetbrains.kotlin.analysis.api.components.KaCompilerTarget
 import org.jetbrains.kotlin.analysis.api.components.KaDebuggerExtension
 import org.jetbrains.kotlin.analysis.api.components.isClassFile
 import org.jetbrains.kotlin.analysis.api.platform.restrictedAnalysis.KaRestrictedAnalysisException
-import org.jetbrains.kotlin.cli.FrontendConfigurationKeys
-import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -181,14 +180,13 @@ class K2KotlinCodeFragmentCompiler : KotlinCodeFragmentCompiler {
 
         val (generatedClassName, generatedEntryFunctionName) =
             KOTLIN_CODE_FRAGMENT_CLASS_AND_FUNCTION_NAMES.get(codeFragment) ?: (GENERATED_CLASS_NAME to GENERATED_FUNCTION_NAME)
-        val compilerConfiguration = CompilerConfiguration().apply {
+        val compilerConfiguration = CompilerConfiguration.create().apply {
             if (module != null) {
                 put(CommonConfigurationKeys.MODULE_NAME, module.name)
             }
             put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, codeFragment.languageVersionSettings)
             put(CODE_FRAGMENT_CLASS_NAME, generatedClassName)
             put(CODE_FRAGMENT_METHOD_NAME, generatedEntryFunctionName)
-            put(FrontendConfigurationKeys.EXTENSIONS_STORAGE, CompilerPluginRegistrar.ExtensionStorage())
         }
 
         return analyze(codeFragment) {

plugins/kotlin/jvm-decompiler/src/org/jetbrains/kotlin/idea/jvmDecompiler/KotlinBytecodeDecompiler.kt

@@ -15,9 +15,7 @@ import org.jetbrains.kotlin.analysis.api.KaExperimentalApi
 import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.components.KaCompilationResult
 import org.jetbrains.kotlin.analysis.api.components.isClassFile
-import org.jetbrains.kotlin.cli.extensionsStorage
-import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
-import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.idea.base.projectStructure.languageVersionSettings
@@ -75,11 +73,8 @@ object KotlinBytecodeDecompiler {
 
     @OptIn(KaExperimentalApi::class)
     private fun bytecodeMapForSourceFile(file: KtFile): Map<File, () -> ByteArray> {
-        val configuration = CompilerConfiguration().apply {
+        val configuration = CompilerConfiguration.create().apply {
             languageVersionSettings = file.languageVersionSettings
-
-            @OptIn(ExperimentalCompilerApi::class)
-            extensionsStorage = CompilerPluginRegistrar.ExtensionStorage()
         }
 
         analyze(file) {

plugins/kotlin/jvm/k1/src/org/jetbrains/kotlin/idea/jvm/k1/scratch/compile/KtScratchExecutionSession.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.components.KaCompilationResult
 import org.jetbrains.kotlin.analysis.api.components.KaCompilerTarget
 import org.jetbrains.kotlin.analysis.api.diagnostics.KaDiagnostic
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.cli.extensionsStorage
 import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
@@ -162,16 +163,13 @@ class KtScratchExecutionSession(
         LOG.printDebugMessage("Temp output dir: ${tmpDir.path}")
 
         val result = analyze(psiFile) {
-            val configuration = CompilerConfiguration().apply {
+            val configuration = CompilerConfiguration.create().apply {
                 val containingModule = psiFile.module
                 if (containingModule != null) {
                     put(CommonConfigurationKeys.MODULE_NAME, containingModule.name)
                 }
 
                 put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, psiFile.languageVersionSettings)
-
-                @OptIn(ExperimentalCompilerApi::class)
-                extensionsStorage = CompilerPluginRegistrar.ExtensionStorage()
             }
 
             try {

plugins/kotlin/jvm/shared/src/org/jetbrains/kotlin/idea/jvm/shared/bytecode/KotlinBytecodeToolWindow.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.analysis.api.components.KaCompiledFile
 import org.jetbrains.kotlin.analysis.api.components.KaCompilerTarget
 import org.jetbrains.kotlin.analysis.api.components.isClassFile
 import org.jetbrains.kotlin.analysis.api.diagnostics.KaDiagnosticWithPsi
+import org.jetbrains.kotlin.cli.create
 import org.jetbrains.kotlin.cli.extensionsStorage
 import org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar
 import org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi
@@ -118,10 +119,7 @@ class KotlinBytecodeToolWindow(
         override fun processRequest(location: Location): BytecodeGenerationResult {
             val ktFile = location.kFile!!
 
-            val configuration = CompilerConfiguration()
-
-            @OptIn(ExperimentalCompilerApi::class)
-            configuration.extensionsStorage = CompilerPluginRegistrar.ExtensionStorage()
+            val configuration = CompilerConfiguration.create()
 
             val containingModule = ktFile.module
             if (containingModule != null) {