Simplify injection of LanguageVersionSettings into JVM analysis

Pass the LanguageVersionSettings instance inside the CompilerConfiguration,
since it's needed anyway. In compiler and tests, the configuration comes from
KotlinCoreEnvironment; in IDE, we're constructing it in JvmAnalyzerFacade

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

@@ -19,9 +19,7 @@ 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.LanguageFeature
-import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.LazyResolveToken
 import org.jetbrains.kotlin.context.ModuleContext
@@ -46,11 +44,10 @@ import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 
-fun StorageComponentContainer.configureJavaTopDownAnalysis(
+private fun StorageComponentContainer.configureJavaTopDownAnalysis(
         moduleContentScope: GlobalSearchScope,
         project: Project,
-        lookupTracker: LookupTracker,
-        languageVersionSettings: LanguageVersionSettings
+        lookupTracker: LookupTracker
 ) {
     useInstance(moduleContentScope)
     useInstance(lookupTracker)
@@ -75,7 +72,6 @@ fun StorageComponentContainer.configureJavaTopDownAnalysis(
     useImpl<JavaSourceElementFactoryImpl>()
     useInstance(InternalFlexibleTypeTransformer)
 
-    useInstance(languageVersionSettings)
     useImpl<CompilerDeserializationConfiguration>()
 }
 
@@ -88,19 +84,20 @@ fun createContainerForLazyResolveWithJava(
         targetEnvironment: TargetEnvironment,
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
-        languageVersionSettings: LanguageVersionSettings,
+        compilerConfiguration: CompilerConfiguration,
         useBuiltInsProvider: Boolean,
-        useLazyResolve: Boolean,
-        compilerConfiguration: CompilerConfiguration
+        useLazyResolve: Boolean
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
     configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, languageVersionSettings)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker)
 
     useInstance(compilerConfiguration)
     useInstance(packagePartProvider)
     useInstance(moduleClassResolver)
     useInstance(declarationProviderFactory)
 
+    useInstance(compilerConfiguration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT))
+
     if (useBuiltInsProvider) {
         useInstance((moduleContext.module.builtIns as JvmBuiltIns).settings)
         useImpl<JvmBuiltInsPackageFragmentProvider>()
@@ -123,18 +120,17 @@ fun createContainerForTopDownAnalyzerForJvm(
         moduleContentScope: GlobalSearchScope,
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
-        languageVersionSettings: LanguageVersionSettings,
         moduleClassResolver: ModuleClassResolver,
         compilerConfiguration: CompilerConfiguration
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
-        CompilerEnvironment, lookupTracker, packagePartProvider, languageVersionSettings,
-        useBuiltInsProvider = true, useLazyResolve = false, compilerConfiguration = compilerConfiguration
+        CompilerEnvironment, lookupTracker, packagePartProvider, compilerConfiguration,
+        useBuiltInsProvider = true, useLazyResolve = false
 )
 
 
-fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis(module: ModuleDescriptor, languageVersionSettings: LanguageVersionSettings) {
-    get<JvmBuiltIns>().initialize(module, languageVersionSettings)
+fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis() {
+    get<JvmBuiltIns>().initialize(get<ModuleDescriptor>(), get<LanguageVersionSettings>())
 }
 
 internal fun JvmBuiltIns.initialize(module: ModuleDescriptor, languageVersionSettings: LanguageVersionSettings) {

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

@@ -19,6 +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.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JvmTarget
@@ -81,15 +82,20 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
             resolverForModule.componentProvider.get<JavaDescriptorResolver>()
         }
 
-        val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
-        val trace = CodeAnalyzerInitializer.getInstance(project).createTrace()
-        //TODO: need to propagate full CompilerConfiguration to frontend
-        val compilerConfiguration = CompilerConfiguration()
-        val platform = languageSettingsProvider.getTargetPlatform(moduleInfo)
-        if (platform is JvmTarget) {
-            compilerConfiguration.put(JVMConfigurationKeys.JVM_TARGET, platform)
+        val configuration = CompilerConfiguration().apply {
+            val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
+            put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project))
+
+            val platform = languageSettingsProvider.getTargetPlatform(moduleInfo)
+            if (platform is JvmTarget) {
+                put(JVMConfigurationKeys.JVM_TARGET, platform)
+            }
+
+            isReadOnly = true
         }
-        compilerConfiguration.isReadOnly = true
+
+        val trace = CodeAnalyzerInitializer.getInstance(project).createTrace()
+
         val container = createContainerForLazyResolveWithJava(
                 moduleContext,
                 trace,
@@ -99,10 +105,9 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 targetEnvironment,
                 LookupTracker.DO_NOTHING,
                 packagePartProvider,
-                languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project),
+                configuration,
                 useBuiltInsProvider = false, // TODO: load built-ins from module dependencies in IDE
-                useLazyResolve = true,
-                compilerConfiguration = compilerConfiguration
+                useLazyResolve = true
         )
 
         StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(container, moduleInfo) }

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

@@ -158,7 +158,7 @@ object TopDownAnalyzerFacadeForJVM {
 
             val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
                     dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker,
-                    packagePartProvider(dependencyScope), languageVersionSettings, moduleClassResolver, configuration
+                    packagePartProvider(dependencyScope), moduleClassResolver, configuration
             )
 
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(dependenciesContainer, null) }
@@ -185,9 +185,9 @@ 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, languageVersionSettings, moduleClassResolver, configuration
+                partProvider, moduleClassResolver, configuration
         ).apply {
-            initJvmBuiltInsForTopDownAnalysis(module, languageVersionSettings)
+            initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get<DeserializationConfiguration>()
 
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(this, null) }

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

@@ -24,10 +24,8 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.common.DefaultAnalyzerFacade
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.SimpleGlobalContext
@@ -260,17 +258,12 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
     ): AnalysisResult {
         @Suppress("NAME_SHADOWING")
         var files = files
-        @Suppress("NAME_SHADOWING")
-        var languageVersionSettings = languageVersionSettings
-        val configuration: CompilerConfiguration
-        if (languageVersionSettings != null) {
-            configuration = environment.configuration.copy()
-            configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
-        }
-        else {
-            configuration = environment.configuration
-            languageVersionSettings = LanguageVersionSettingsImpl.DEFAULT
-        }
+
+        val configuration =
+                if (languageVersionSettings != null)
+                    environment.configuration.copy().apply { put(LANGUAGE_VERSION_SETTINGS, languageVersionSettings) }
+                else
+                    environment.configuration
 
         // New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
         // albeit with same class names
@@ -318,11 +311,10 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                 moduleContentScope,
                 LookupTracker.DO_NOTHING,
                 JvmPackagePartProvider(environment, moduleContentScope),
-                languageVersionSettings,
                 moduleClassResolver,
                 configuration
         )
-        container.initJvmBuiltInsForTopDownAnalysis(moduleDescriptor, languageVersionSettings)
+        container.initJvmBuiltInsForTopDownAnalysis()
         moduleClassResolver.resolver = container.get<JavaDescriptorResolver>()
 
         moduleDescriptor.initialize(CompositePackageFragmentProvider(listOf(