Propagate 'CompilerConfiguration' to frontend checkers

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

@@ -19,6 +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.container.*
@@ -89,11 +90,13 @@ fun createContainerForLazyResolveWithJava(
         packagePartProvider: PackagePartProvider,
         languageVersionSettings: LanguageVersionSettings,
         useBuiltInsProvider: Boolean,
-        useLazyResolve: Boolean
+        useLazyResolve: Boolean,
+        compilerConfiguration: CompilerConfiguration
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, languageVersionSettings)
 
+    useInstance(compilerConfiguration)
     useInstance(packagePartProvider)
     useInstance(moduleClassResolver)
     useInstance(declarationProviderFactory)
@@ -121,11 +124,12 @@ fun createContainerForTopDownAnalyzerForJvm(
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
         languageVersionSettings: LanguageVersionSettings,
-        moduleClassResolver: ModuleClassResolver
+        moduleClassResolver: ModuleClassResolver,
+        compilerConfiguration: CompilerConfiguration
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
         CompilerEnvironment, lookupTracker, packagePartProvider, languageVersionSettings,
-        useBuiltInsProvider = true, useLazyResolve = false
+        useBuiltInsProvider = true, useLazyResolve = false, compilerConfiguration = compilerConfiguration
 )
 
 

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

@@ -19,6 +19,9 @@ 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.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
@@ -78,7 +81,15 @@ 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)
+        }
+        compilerConfiguration.isReadOnly = true
         val container = createContainerForLazyResolveWithJava(
                 moduleContext,
                 trace,
@@ -88,9 +99,10 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 targetEnvironment,
                 LookupTracker.DO_NOTHING,
                 packagePartProvider,
-                LanguageVersionSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo),
+                languageSettingsProvider.getLanguageVersionSettings(moduleInfo),
                 useBuiltInsProvider = false, // TODO: load built-ins from module dependencies in IDE
-                useLazyResolve = true
+                useLazyResolve = true,
+                compilerConfiguration = compilerConfiguration
         )
 
         StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(container, moduleInfo) }

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

@@ -157,7 +157,7 @@ object TopDownAnalyzerFacadeForJVM {
 
             val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
                     dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker,
-                    packagePartProvider(dependencyScope), languageVersionSettings, moduleClassResolver
+                    packagePartProvider(dependencyScope), languageVersionSettings, moduleClassResolver, configuration
             )
 
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(dependenciesContainer, null) }
@@ -182,7 +182,7 @@ object TopDownAnalyzerFacadeForJVM {
                 IncrementalPackagePartProvider.create(
                         packagePartProvider(sourceScope), targetIds, incrementalComponents, storageManager
                 ),
-                languageVersionSettings, moduleClassResolver
+                languageVersionSettings, moduleClassResolver, configuration
         ).apply {
             initJvmBuiltInsForTopDownAnalysis(module, languageVersionSettings)
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(this, null) }