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) }

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.utils.DescriptionAware
 import org.jetbrains.kotlin.utils.singletonOrEmptyList
 import java.util.*
 
@@ -257,14 +258,18 @@ private class DelegatingPackageFragmentProvider(
     }
 }
 
-interface LanguageVersionSettingsProvider {
+interface LanguageSettingsProvider {
     fun getLanguageVersionSettings(moduleInfo: ModuleInfo): LanguageVersionSettings
 
-    object Default : LanguageVersionSettingsProvider {
+    fun getTargetPlatform(moduleInfo: ModuleInfo): DescriptionAware
+
+    object Default : LanguageSettingsProvider {
         override fun getLanguageVersionSettings(moduleInfo: ModuleInfo) = LanguageVersionSettingsImpl.DEFAULT
+
+        override fun getTargetPlatform(moduleInfo: ModuleInfo): DescriptionAware = DescriptionAware.NoVersion
     }
 
     companion object {
-        fun getInstance(project: Project) = ServiceManager.getService(project, LanguageVersionSettingsProvider::class.java) ?: Default
+        fun getInstance(project: Project) = ServiceManager.getService(project, LanguageSettingsProvider::class.java) ?: Default
     }
 }

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.frontend.di
 
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
@@ -142,6 +143,8 @@ fun createContainerForLazyResolve(
     useInstance(declarationProviderFactory)
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(languageVersionSettings)
+    //TODO: need to propagate full CompilerConfiguration to frontend
+    useInstance(CompilerConfiguration.EMPTY)
 
     useImpl<FileScopeProviderImpl>()
     useImpl<CompilerDeserializationConfiguration>()

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve.calls
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.getReturnTypeFromFunctionType
 import org.jetbrains.kotlin.builtins.isFunctionType
+import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.psi.*
@@ -61,7 +62,8 @@ class CallCompleter(
         private val callCheckers: Iterable<CallChecker>,
         private val builtIns: KotlinBuiltIns,
         private val fakeCallResolver: FakeCallResolver,
-        private val languageVersionSettings: LanguageVersionSettings
+        private val languageVersionSettings: LanguageVersionSettings,
+        private val compilerConfiguration: CompilerConfiguration
 ) {
     fun <D : CallableDescriptor> completeCall(
             context: BasicCallResolutionContext,
@@ -93,7 +95,7 @@ class CallCompleter(
                     else resolvedCall.call.callElement
 
             if (context.trace.wantsDiagnostics()) {
-                val callCheckerContext = CallCheckerContext(context, languageVersionSettings)
+                val callCheckerContext = CallCheckerContext(context, languageVersionSettings, compilerConfiguration)
                 for (callChecker in callCheckers) {
                     callChecker.check(resolvedCall, reportOn, callCheckerContext)
                 }

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

@@ -17,6 +17,7 @@
 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
@@ -37,7 +38,8 @@ 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
@@ -48,7 +50,7 @@ class CallCheckerContext(
     val isAnnotationContext: Boolean
         get() = resolutionContext.isAnnotationContext
 
-    constructor(c: ResolutionContext<*>, languageVersionSettings: LanguageVersionSettings) : this(c, c.trace, languageVersionSettings)
+    constructor(c: ResolutionContext<*>, languageVersionSettings: LanguageVersionSettings, configuration: CompilerConfiguration) : this(c, c.trace, languageVersionSettings, configuration)
 }
 
 // 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

@@ -672,7 +672,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         trace.record(CALL, expression, call);
 
         if (context.trace.wantsDiagnostics()) {
-            CallCheckerContext callCheckerContext = new CallCheckerContext(context, components.languageVersionSettings);
+            CallCheckerContext callCheckerContext =
+                    new CallCheckerContext(context, components.languageVersionSettings, components.compilerConfiguration);
             for (CallChecker checker : components.callCheckers) {
                 checker.check(resolvedCall, expression, callCheckerContext);
             }
@@ -977,7 +978,8 @@ 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 = new CallCheckerContext(context, trace, components.languageVersionSettings);
+                    CallCheckerContext callCheckerContext =
+                            new CallCheckerContext(context, trace, components.languageVersionSettings, components.compilerConfiguration);
                     for (CallChecker checker : components.callCheckers) {
                         checker.check(resolvedCall, expression, callCheckerContext);
                     }
@@ -1044,7 +1046,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         resolvedCall.markCallAsCompleted();
 
         if (context.trace.wantsDiagnostics()) {
-            CallCheckerContext callCheckerContext = new CallCheckerContext(context, components.languageVersionSettings);
+            CallCheckerContext callCheckerContext =
+                    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,6 +18,7 @@ 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;
@@ -60,6 +61,7 @@ public class ExpressionTypingComponents {
     /*package*/ OverloadChecker overloadChecker;
     /*package*/ LanguageVersionSettings languageVersionSettings;
     /*package*/ Iterable<RttiExpressionChecker> rttiExpressionCheckers;
+    /*package*/ CompilerConfiguration compilerConfiguration;
 
     @Inject
     public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -200,4 +202,9 @@ public class ExpressionTypingComponents {
     public void setRttiExpressionCheckers(@NotNull Iterable<RttiExpressionChecker> rttiExpressionCheckers) {
         this.rttiExpressionCheckers = rttiExpressionCheckers;
     }
+
+    @Inject
+    public void setCompilerConfiguration(CompilerConfiguration compilerConfiguration) {
+        this.compilerConfiguration = compilerConfiguration;
+    }
 }

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

@@ -319,7 +319,8 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                 LookupTracker.DO_NOTHING,
                 JvmPackagePartProvider(environment, moduleContentScope),
                 languageVersionSettings,
-                moduleClassResolver
+                moduleClassResolver,
+                configuration
         )
         container.initJvmBuiltInsForTopDownAnalysis(moduleDescriptor, languageVersionSettings)
         moduleClassResolver.resolver = container.get<JavaDescriptorResolver>()

compiler/util/src/org/jetbrains/kotlin/utils/DescriptionAware.kt

@@ -18,4 +18,8 @@ package org.jetbrains.kotlin.utils;
 
 interface DescriptionAware {
     val description: String
+
+    object NoVersion : DescriptionAware {
+        override val description = ""
+    }
 }

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

@@ -61,7 +61,7 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
                 BindingTraceContext(),
                 JsPlatform,
                 targetEnvironment,
-                LanguageVersionSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo)
+                LanguageSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo)
         )
         var packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
 

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

@@ -79,7 +79,7 @@ val Module.languageVersionSettings: LanguageVersionSettings
         return LanguageVersionSettingsImpl(languageVersion, ApiVersion.createByLanguageVersion(apiVersion), extraLanguageFeatures)
     }
 
-private val Module.targetPlatform: TargetPlatformKind<*>?
+val Module.targetPlatform: TargetPlatformKind<*>?
     get() = KotlinFacetSettingsProvider.getInstance(project).getSettings(this).versionInfo.targetPlatformKind
 
 private val Module.implementsCommonModule: Boolean

idea/idea-jps-common/src/org/jetbrains/kotlin/config/KotlinFacetSettings.kt

@@ -39,9 +39,9 @@ sealed class TargetPlatformKind<out Version : DescriptionAware>(
         }
     }
 
-    object JavaScript : TargetPlatformKind<NoVersion>(NoVersion, "JavaScript")
+    object JavaScript : TargetPlatformKind<DescriptionAware.NoVersion>(DescriptionAware.NoVersion, "JavaScript")
 
-    object Common : TargetPlatformKind<NoVersion>(NoVersion, "Common (experimental)")
+    object Common : TargetPlatformKind<DescriptionAware.NoVersion>(DescriptionAware.NoVersion, "Common (experimental)")
 
     companion object {
 
@@ -49,10 +49,6 @@ sealed class TargetPlatformKind<out Version : DescriptionAware>(
     }
 }
 
-object NoVersion : DescriptionAware {
-    override val description = ""
-}
-
 data class KotlinVersionInfo(
         var languageLevel: LanguageVersion? = null,
         var apiLevel: LanguageVersion? = null,

idea/src/META-INF/plugin.xml

@@ -305,7 +305,7 @@
     <projectService serviceInterface="org.jetbrains.kotlin.console.KotlinConsoleKeeper"
                     serviceImplementation="org.jetbrains.kotlin.console.KotlinConsoleKeeper"/>
 
-    <projectService serviceInterface="org.jetbrains.kotlin.analyzer.LanguageVersionSettingsProvider"
+    <projectService serviceInterface="org.jetbrains.kotlin.analyzer.LanguageSettingsProvider"
                     serviceImplementation="org.jetbrains.kotlin.idea.compiler.LanguageVersionSettingsProviderImpl"/>
 
     <projectService serviceInterface="org.jetbrains.kotlin.config.KotlinFacetSettingsProvider"

idea/src/org/jetbrains/kotlin/idea/compiler/LanguageVersionSettingsProviderImpl.kt

@@ -16,15 +16,21 @@
 
 package org.jetbrains.kotlin.idea.compiler
 
-import org.jetbrains.kotlin.analyzer.LanguageVersionSettingsProvider
+import org.jetbrains.kotlin.analyzer.LanguageSettingsProvider
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
+import org.jetbrains.kotlin.idea.project.targetPlatform
+import org.jetbrains.kotlin.utils.DescriptionAware
 
-class LanguageVersionSettingsProviderImpl : LanguageVersionSettingsProvider {
+class LanguageVersionSettingsProviderImpl : LanguageSettingsProvider {
     override fun getLanguageVersionSettings(moduleInfo: ModuleInfo): LanguageVersionSettings {
         return (moduleInfo as? ModuleSourceInfo)?.module?.languageVersionSettings ?: LanguageVersionSettingsImpl.DEFAULT
     }
+
+    override fun getTargetPlatform(moduleInfo: ModuleInfo): DescriptionAware {
+        return (moduleInfo as? ModuleSourceInfo)?.module?.targetPlatform?.version ?: DescriptionAware.NoVersion
+    }
 }