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 languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
-        val configuration = CompilerConfiguration().apply {
-            languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
-            put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
-            isReadOnly = true
-        }
 
         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>()

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/DefaultAnalyzerFacade.kt

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-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.kotlin.MetadataFinderFactory
@@ -49,11 +48,9 @@ import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmen
  * See [TargetPlatform.Default]
  */
 object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
-    private val compilerConfiguration = CompilerConfiguration().apply {
+    private val languageVersionSettings = LanguageVersionSettingsImpl(
-        languageVersionSettings = LanguageVersionSettingsImpl(
+            LanguageVersion.LATEST, ApiVersion.LATEST, additionalFeatures = setOf(LanguageFeature.MultiPlatformProjects)
-                LanguageVersion.LATEST, ApiVersion.LATEST, additionalFeatures = setOf(LanguageFeature.MultiPlatformProjects)
+    )
-        )
-    }
 
     private class SourceModuleInfo(
             override val name: Name,
@@ -135,7 +132,7 @@ object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzer>()
         useImpl<FileScopeProviderImpl>()
-        configureCommon(compilerConfiguration)
+        useInstance(languageVersionSettings)
         useImpl<CompilerDeserializationConfiguration>()
         useInstance(packagePartProvider)
         useInstance(declarationProviderFactory)

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

@@ -16,9 +16,9 @@
 
 package org.jetbrains.kotlin.frontend.di
 
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.config.TargetPlatformVersion
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
@@ -73,18 +73,13 @@ fun StorageComponentContainer.configureModule(
     useInstance(trace)
 }
 
-fun StorageComponentContainer.configureCommon(configuration: CompilerConfiguration) {
-    useInstance(configuration)
-    useInstance(configuration.languageVersionSettings)
-}
-
 fun createContainerForBodyResolve(
         moduleContext: ModuleContext,
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         statementFilter: StatementFilter,
         targetPlatformVersion: TargetPlatformVersion,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("BodyResolve", platform) {
     configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
@@ -92,7 +87,7 @@ fun createContainerForBodyResolve(
 
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(BodyResolveCache.ThrowException)
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
 
     useImpl<BodyResolver>()
 }
@@ -104,7 +99,7 @@ fun createContainerForLazyBodyResolve(
         platform: TargetPlatform,
         bodyResolveCache: BodyResolveCache,
         targetPlatformVersion: TargetPlatformVersion,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("LazyBodyResolve", platform) {
     configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
@@ -112,7 +107,7 @@ fun createContainerForLazyBodyResolve(
     useInstance(kotlinCodeAnalyzer)
     useInstance(kotlinCodeAnalyzer.fileScopeProvider)
     useInstance(bodyResolveCache)
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
     useImpl<LazyTopDownAnalyzer>()
     useImpl<BasicAbsentDescriptorHandler>()
 }
@@ -123,7 +118,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
         platform: TargetPlatform,
         lookupTracker: LookupTracker,
         targetPlatformVersion: TargetPlatformVersion,
-        compilerConfiguration: CompilerConfiguration,
+        languageVersionSettings: LanguageVersionSettings,
         statementFilter: StatementFilter,
         localClassDescriptorHolder: LocalClassDescriptorHolder
 ): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", platform) {
@@ -143,7 +138,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
     useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
     useImpl<LocalLazyDeclarationResolver>()
 
-    configureCommon(compilerConfiguration)
+    useInstance(languageVersionSettings)
     useInstance(statementFilter)
 }
 
@@ -154,14 +149,13 @@ fun createContainerForLazyResolve(
         platform: TargetPlatform,
         targetPlatformVersion: TargetPlatformVersion,
         targetEnvironment: TargetEnvironment,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): StorageComponentContainer = createContainer("LazyResolve", platform) {
     configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(LookupTracker.DO_NOTHING)
-
+    useInstance(languageVersionSettings)
-    configureCommon(compilerConfiguration)
 
     useImpl<FileScopeProviderImpl>()
     useImpl<CompilerDeserializationConfiguration>()
@@ -179,5 +173,5 @@ fun createLazyResolveSession(moduleContext: ModuleContext, files: Collection<KtF
                 TargetPlatform.Default,
                 TargetPlatformVersion.NoVersion,
                 CompilerEnvironment,
-                CompilerConfiguration.EMPTY
+                LanguageVersionSettingsImpl.DEFAULT
         ).get<ResolveSession>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt

@@ -61,8 +61,7 @@ class CallCompleter(
         private val dataFlowAnalyzer: DataFlowAnalyzer,
         private val callCheckers: Iterable<CallChecker>,
         private val builtIns: KotlinBuiltIns,
-        private val languageVersionSettings: LanguageVersionSettings,
+        private val languageVersionSettings: LanguageVersionSettings
-        private val compilerConfiguration: CompilerConfiguration
 ) {
     fun <D : CallableDescriptor> completeCall(
             context: BasicCallResolutionContext,
@@ -93,7 +92,7 @@ class CallCompleter(
                     if (calleeExpression != null && !calleeExpression.isFakeElement) calleeExpression
                     else resolvedCall.call.callElement
 
-            val callCheckerContext = CallCheckerContext(context, languageVersionSettings, compilerConfiguration)
+            val callCheckerContext = CallCheckerContext(context, languageVersionSettings)
             for (callChecker in callCheckers) {
                 callChecker.check(resolvedCall, reportOn, callCheckerContext)
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CallChecker.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.resolve.calls.checkers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
@@ -38,8 +37,7 @@ interface CallChecker {
 class CallCheckerContext(
         val resolutionContext: ResolutionContext<*>,
         val trace: BindingTrace,
-        val languageVersionSettings: LanguageVersionSettings,
+        val languageVersionSettings: LanguageVersionSettings
-        val compilerConfiguration: CompilerConfiguration
 ) {
     val scope: LexicalScope
         get() = resolutionContext.scope
@@ -50,7 +48,7 @@ class CallCheckerContext(
     val isAnnotationContext: Boolean
         get() = resolutionContext.isAnnotationContext
 
-    constructor(c: ResolutionContext<*>, languageVersionSettings: LanguageVersionSettings, configuration: CompilerConfiguration) : this(c, c.trace, languageVersionSettings, configuration)
+    constructor(c: ResolutionContext<*>, languageVersionSettings: LanguageVersionSettings) : this(c, c.trace, languageVersionSettings)
 }
 
 // Use this utility to avoid premature computation of deferred return type of a resolved callable descriptor.

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -687,8 +687,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         trace.record(CALL, expression, call);
 
         if (context.trace.wantsDiagnostics()) {
-            CallCheckerContext callCheckerContext =
+            CallCheckerContext callCheckerContext = new CallCheckerContext(context, components.languageVersionSettings);
-                    new CallCheckerContext(context, components.languageVersionSettings, components.compilerConfiguration);
             for (CallChecker checker : components.callCheckers) {
                 checker.check(resolvedCall, expression, callCheckerContext);
             }
@@ -996,8 +995,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 if (resolvedCall != null && trace.wantsDiagnostics()) {
                     // Call must be validated with the actual, not temporary trace in order to report operator diagnostic
                     // Only unary assignment expressions (++, --) and +=/... must be checked, normal assignments have the proper trace
-                    CallCheckerContext callCheckerContext =
+                    CallCheckerContext callCheckerContext = new CallCheckerContext(context, trace, components.languageVersionSettings);
-                            new CallCheckerContext(context, trace, components.languageVersionSettings, components.compilerConfiguration);
                     for (CallChecker checker : components.callCheckers) {
                         checker.check(resolvedCall, expression, callCheckerContext);
                     }
@@ -1064,8 +1062,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         resolvedCall.markCallAsCompleted();
 
         if (context.trace.wantsDiagnostics()) {
-            CallCheckerContext callCheckerContext =
+            CallCheckerContext callCheckerContext = new CallCheckerContext(context, components.languageVersionSettings);
-                    new CallCheckerContext(context, components.languageVersionSettings, components.compilerConfiguration);
             for (CallChecker checker : components.callCheckers) {
                 checker.check(resolvedCall, expression, callCheckerContext);
             }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.types.expressions;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.incremental.components.LookupTracker;
@@ -61,7 +60,6 @@ public class ExpressionTypingComponents {
     /*package*/ OverloadChecker overloadChecker;
     /*package*/ LanguageVersionSettings languageVersionSettings;
     /*package*/ Iterable<RttiExpressionChecker> rttiExpressionCheckers;
-    /*package*/ CompilerConfiguration compilerConfiguration;
 
     @Inject
     public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -202,9 +200,4 @@ public class ExpressionTypingComponents {
     public void setRttiExpressionCheckers(@NotNull Iterable<RttiExpressionChecker> rttiExpressionCheckers) {
         this.rttiExpressionCheckers = rttiExpressionCheckers;
     }
-
-    @Inject
-    public void setCompilerConfiguration(CompilerConfiguration compilerConfiguration) {
-        this.compilerConfiguration = compilerConfiguration;
-    }
 }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -64,7 +64,7 @@ class LocalClassifierAnalyzer(
         private val lookupTracker: LookupTracker,
         private val supertypeLoopChecker: SupertypeLoopChecker,
         private val targetPlatformVersion: TargetPlatformVersion,
-        private val compilerConfiguration: CompilerConfiguration,
+        private val languageVersionSettings: LanguageVersionSettings,
         private val delegationFilter: DelegationFilter
 ) {
     fun processClassOrObject(
@@ -82,7 +82,7 @@ class LocalClassifierAnalyzer(
                 platform,
                 lookupTracker,
                 targetPlatformVersion,
-                compilerConfiguration,
+                languageVersionSettings,
                 context.statementFilter,
                 LocalClassDescriptorHolder(
                         scope,
@@ -96,7 +96,7 @@ class LocalClassifierAnalyzer(
                         typeResolver,
                         annotationResolver,
                         supertypeLoopChecker,
-                        compilerConfiguration.languageVersionSettings,
+                        languageVersionSettings,
                         SyntheticResolveExtension.getInstance(project),
                         delegationFilter
                 )

compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt

@@ -266,10 +266,6 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
         @Suppress("NAME_SHADOWING")
         var files = files
 
-        val configuration = environment.configuration.copy().apply {
-            this.languageVersionSettings = languageVersionSettings
-        }
-
         // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
         // albeit with same class names
         // See TopDownAnalyzerFacadeForJVM#analyzeFilesWithJavaIntegration
@@ -282,7 +278,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                     moduleContext.project,
                     files,
                     moduleTrace,
-                    configuration,
+                    environment.configuration.copy().apply { this.languageVersionSettings = languageVersionSettings },
                     { scope -> JvmPackagePartProvider(environment, scope) }
             )
         }
@@ -318,7 +314,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                 JvmPackagePartProvider(environment, moduleContentScope),
                 moduleClassResolver,
                 JvmTarget.JVM_1_6,
-                configuration
+                languageVersionSettings
         )
         container.initJvmBuiltInsForTopDownAnalysis()
         moduleClassResolver.resolver = container.get<JavaDescriptorResolver>()

compiler/tests-common/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -20,8 +20,8 @@ import com.intellij.openapi.editor.impl.DocumentImpl
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -64,7 +64,7 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
                 JvmPlatform,
                 JvmTarget.JVM_1_6,
                 targetEnvironment,
-                CompilerConfiguration.EMPTY
+                LanguageVersionSettingsImpl.DEFAULT
         )
 
         val resolveSession = container.get<ResolveSession>()

compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt

@@ -17,15 +17,14 @@
 package org.jetbrains.kotlin.tests.di
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.getValue
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-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.resolve.DescriptorResolver
@@ -40,7 +39,7 @@ fun createContainerForTests(project: Project, module: ModuleDescriptor): Contain
     return ContainerForTests(createContainer("Tests", JvmPlatform) {
         configureModule(ModuleContext(module, project), JvmPlatform, JvmTarget.JVM_1_6)
         useInstance(LookupTracker.DO_NOTHING)
-        configureCommon(CompilerConfiguration.EMPTY)
+        useInstance(LanguageVersionSettingsImpl.DEFAULT)
         useImpl<ExpressionTypingServices>()
     })
 }

idea/ide-common/src/org/jetbrains/kotlin/caches/resolve/JsAnalyzerFacade.kt

@@ -19,9 +19,7 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.caches.resolve.LibraryModuleInfo
-import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.TargetPlatformVersion
-import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -56,11 +54,7 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
                 project, moduleContext.storageManager, syntheticFiles, if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
         )
 
-        // TODO: deduplicate this with JvmAnalyzerFacade
+        val languageVersionSettings = LanguageSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo, project)
-        val configuration = CompilerConfiguration().apply {
-            languageVersionSettings = LanguageSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo, project)
-            isReadOnly = true
-        }
 
         val container = createContainerForLazyResolve(
                 moduleContext,
@@ -69,7 +63,7 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
                 JsPlatform,
                 TargetPlatformVersion.NoVersion,
                 targetEnvironment,
-                configuration
+                languageVersionSettings
         )
         var packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
-import org.jetbrains.kotlin.idea.project.createCompilerConfiguration
 import org.jetbrains.kotlin.idea.project.jvmTarget
+import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.*
@@ -175,7 +175,7 @@ private object KotlinResolveDataProvider {
                     targetPlatform,
                     componentProvider.get<BodyResolveCache>(),
                     analyzableElement.jvmTarget,
-                    analyzableElement.createCompilerConfiguration()
+                    analyzableElement.languageVersionSettings
             ).get<LazyTopDownAnalyzer>()
 
             lazyTopDownAnalyzer.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, listOf(analyzableElement))

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt

@@ -148,12 +148,6 @@ private fun getExtraLanguageFeatures(
     }
 }
 
-fun KtElement.createCompilerConfiguration(): CompilerConfiguration = CompilerConfiguration().apply {
-    languageVersionSettings = this@createCompilerConfiguration.languageVersionSettings
-    put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
-    isReadOnly = true
-}
-
 val KtElement.languageVersionSettings: LanguageVersionSettings
     get() {
         if (ServiceManager.getService(containingKtFile.project, ProjectFileIndex::class.java) == null) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt

@@ -589,7 +589,7 @@ class ResolveElementCache(
                 targetPlatform,
                 statementFilter,
                 file.jvmTarget,
-                file.createCompilerConfiguration()
+                file.languageVersionSettings
         ).get<BodyResolver>()
     }
 

js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt

@@ -16,14 +16,13 @@
 
 package org.jetbrains.kotlin.frontend.js.di
 
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-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.js.resolve.JsPlatform
@@ -40,7 +39,7 @@ fun createTopDownAnalyzerForJs(
         moduleContext: ModuleContext,
         bindingTrace: BindingTrace,
         declarationProviderFactory: DeclarationProviderFactory,
-        compilerConfiguration: CompilerConfiguration
+        languageVersionSettings: LanguageVersionSettings
 ): LazyTopDownAnalyzer {
     val storageComponentContainer = createContainer("TopDownAnalyzerForJs", JsPlatform) {
         configureModule(moduleContext, JsPlatform, TargetPlatformVersion.NoVersion, bindingTrace)
@@ -51,7 +50,7 @@ fun createTopDownAnalyzerForJs(
         CompilerEnvironment.configure(this)
 
         useInstance(LookupTracker.DO_NOTHING)
-        configureCommon(compilerConfiguration)
+        useInstance(languageVersionSettings)
         useImpl<ResolveSession>()
         useImpl<LazyTopDownAnalyzer>()
     }.apply {

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.js.analyze
 
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
@@ -55,7 +56,7 @@ object TopDownAnalyzerFacadeForJS {
         val analyzerForJs = createTopDownAnalyzerForJs(
                 moduleContext, trace,
                 FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
-                config.configuration
+                config.configuration.languageVersionSettings
         )
         analyzerForJs.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
         return JsAnalysisResult.success(trace, moduleContext.module)