Do not inject CompilerConfiguration into compiler front-end

Inject LanguageVersionSettings instead; all information relevant to the
analysis should be now passed via an instance of LanguageVersionSettings
(which should be renamed to a more general name in the future).

This is partially a revert of d499998 and related commits

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.frontend.java.di
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.JvmBuiltInsPackageFragmentProvider
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
@@ -28,7 +27,6 @@ import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
-import org.jetbrains.kotlin.frontend.di.configureCommon
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
@@ -89,7 +87,7 @@ fun createContainerForLazyResolveWithJava(
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
         jvmTarget: JvmTarget,
-        compilerConfiguration: CompilerConfiguration,
+        languageVersionSettings: LanguageVersionSettings,
         useBuiltInsProvider: Boolean,
         useLazyResolve: Boolean
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
@@ -100,7 +98,7 @@ fun createContainerForLazyResolveWithJava(
     useInstance(moduleClassResolver)
     useInstance(declarationProviderFactory)
 
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
 
     if (useBuiltInsProvider) {
         useInstance((moduleContext.module.builtIns as JvmBuiltIns).settings)
@@ -126,10 +124,10 @@ fun createContainerForTopDownAnalyzerForJvm(
         packagePartProvider: PackagePartProvider,
         moduleClassResolver: ModuleClassResolver,
         jvmTarget: JvmTarget,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
-        CompilerEnvironment, lookupTracker, packagePartProvider, jvmTarget, compilerConfiguration,
+        CompilerEnvironment, lookupTracker, packagePartProvider, jvmTarget, languageVersionSettings,
         useBuiltInsProvider = true, useLazyResolve = false
 )
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt

@@ -19,10 +19,7 @@ package org.jetbrains.kotlin.resolve.jvm
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JvmTarget
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -84,12 +81,7 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
 
         val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
         val jvmTarget = languageSettingsProvider.getTargetPlatform(moduleInfo) as? JvmTarget ?: JvmTarget.JVM_1_6
-
-        val configuration = CompilerConfiguration().apply {
-            languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
-            put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
-            isReadOnly = true
-        }
+        val languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
 
         val trace = CodeAnalyzerInitializer.getInstance(project).createTrace()
 
@@ -103,7 +95,7 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 LookupTracker.DO_NOTHING,
                 packagePartProvider,
                 jvmTarget,
-                configuration,
+                languageVersionSettings,
                 useBuiltInsProvider = false, // TODO: load built-ins from module dependencies in IDE
                 useLazyResolve = true
         )

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt

@@ -133,11 +133,12 @@ object TopDownAnalyzerFacadeForJVM {
         val moduleClassResolver = SourceOrBinaryModuleClassResolver(sourceScope)
 
         val jvmTarget = configuration.get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.JVM_1_6
+        val languageVersionSettings = configuration.languageVersionSettings
 
         val optionalBuiltInsModule =
                 if (configuration.getBoolean(JVMConfigurationKeys.ADD_BUILT_INS_FROM_COMPILER_TO_DEPENDENCIES)) {
                     if (createBuiltInsFromModule)
-                        JvmBuiltIns(storageManager).apply { initialize(module, configuration.languageVersionSettings) }.builtInsModule
+                        JvmBuiltIns(storageManager).apply { initialize(module, languageVersionSettings) }.builtInsModule
                     else module.builtIns.builtInsModule
                 }
                 else null
@@ -153,7 +154,7 @@ object TopDownAnalyzerFacadeForJVM {
 
             val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
                     dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker,
-                    packagePartProvider(dependencyScope), moduleClassResolver, jvmTarget, configuration
+                    packagePartProvider(dependencyScope), moduleClassResolver, jvmTarget, languageVersionSettings
             )
 
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(dependenciesContainer, null) }
@@ -180,7 +181,7 @@ object TopDownAnalyzerFacadeForJVM {
         // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker,
-                partProvider, moduleClassResolver, jvmTarget, configuration
+                partProvider, moduleClassResolver, jvmTarget, languageVersionSettings
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get<DeserializationConfiguration>()