Add extension CompilerConfiguration.languageVersionSettings for convenience

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -166,7 +166,7 @@ class GenerationState @JvmOverloads constructor(
 
     val generateParametersMetadata: Boolean = configuration.getBoolean(JVMConfigurationKeys.PARAMETERS_METADATA)
 
-    val languageVersionSettings = configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+    val languageVersionSettings = configuration.languageVersionSettings
     val shouldInlineConstVals = languageVersionSettings.supportsFeature(LanguageFeature.InlineConstVals)
 
     init {

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java

@@ -22,10 +22,7 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.util.concurrency.AppExecutorUtil;
 import com.intellij.util.concurrency.AppScheduledExecutorService;
-import com.sampullara.cli.Args;
-import kotlin.Pair;
 import kotlin.collections.ArraysKt;
-import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.fusesource.jansi.AnsiConsole;
 import org.jetbrains.annotations.NotNull;
@@ -44,7 +41,6 @@ import org.jetbrains.kotlin.utils.StringsKt;
 
 import java.io.PrintStream;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Properties;
 
@@ -279,8 +275,8 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> {
             extraLanguageFeatures.add(coroutinesApplicabilityLevel);
         }
 
-        configuration.put(
-                CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS,
+        CommonConfigurationKeysKt.setLanguageVersionSettings(
+                configuration,
                 new LanguageVersionSettingsImpl(
                         languageVersion,
                         ApiVersion.createByLanguageVersion(apiVersion),

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JvmRuntimeVersionsConsistencyChecker.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.cli.jvm
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.cli.common.CLICompiler
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -32,19 +31,16 @@ import java.util.jar.Manifest
 object JvmRuntimeVersionsConsistencyChecker {
     private val LOG = Logger.getInstance(JvmRuntimeVersionsConsistencyChecker::class.java)
 
-    private fun fatal(message: String): Nothing {
-        LOG.error(message)
-        throw AssertionError(message)
-    }
-
-    private fun <T> T?.assertNotNull(message: () -> String): T =
-            if (this == null) fatal(message()) else this
+    private fun <T> T?.assertNotNull(lazyMessage: () -> String): T =
+            this ?: lazyMessage().let { message ->
+                LOG.error(message)
+                throw AssertionError(message)
+            }
 
     private const val META_INF = "META-INF"
     private const val MANIFEST_MF = "$META_INF/MANIFEST.MF"
 
     private const val MANIFEST_KOTLIN_VERSION_ATTRIBUTE = "manifest.impl.attribute.kotlin.version"
-    private const val MANIFEST_KOTLIN_VERSION_VALUE = "manifest.impl.value.kotlin.version"
     private const val MANIFEST_KOTLIN_RUNTIME_COMPONENT = "manifest.impl.attribute.kotlin.runtime.component"
     private const val MANIFEST_KOTLIN_RUNTIME_COMPONENT_CORE = "manifest.impl.value.kotlin.runtime.component.core"
     private const val MANIFEST_KOTLIN_RUNTIME_COMPONENT_MAIN = "manifest.impl.value.kotlin.runtime.component.main"
@@ -57,8 +53,6 @@ object JvmRuntimeVersionsConsistencyChecker {
     )
 
     private val KOTLIN_VERSION_ATTRIBUTE: String
-    private val CURRENT_COMPILER_VERSION: MavenComparableVersion
-
     private val KOTLIN_RUNTIME_COMPONENT_ATTRIBUTE: String
     private val KOTLIN_RUNTIME_COMPONENT_CORE: String
     private val KOTLIN_RUNTIME_COMPONENT_MAIN: String
@@ -76,18 +70,6 @@ object JvmRuntimeVersionsConsistencyChecker {
 
         KOTLIN_VERSION_ATTRIBUTE = manifestProperties.getProperty(MANIFEST_KOTLIN_VERSION_ATTRIBUTE)
                 .assertNotNull { "$MANIFEST_KOTLIN_VERSION_ATTRIBUTE not found in kotlinManifest.properties" }
-
-        CURRENT_COMPILER_VERSION = run {
-            val kotlinVersionString = manifestProperties.getProperty(MANIFEST_KOTLIN_VERSION_VALUE)
-                    .assertNotNull { "$MANIFEST_KOTLIN_VERSION_VALUE not found in kotlinManifest.properties" }
-
-            MavenComparableVersion(kotlinVersionString)
-        }
-
-        if (CURRENT_COMPILER_VERSION != ApiVersion.LATEST.version) {
-            fatal("Kotlin compiler version $CURRENT_COMPILER_VERSION in kotlinManifest.properties doesn't match ${ApiVersion.LATEST}")
-        }
-
         KOTLIN_RUNTIME_COMPONENT_ATTRIBUTE = manifestProperties.getProperty(MANIFEST_KOTLIN_RUNTIME_COMPONENT)
                 .assertNotNull { "$MANIFEST_KOTLIN_RUNTIME_COMPONENT not found in kotlinManifest.properties" }
         KOTLIN_RUNTIME_COMPONENT_CORE = manifestProperties.getProperty(MANIFEST_KOTLIN_RUNTIME_COMPONENT_CORE)
@@ -118,8 +100,8 @@ object JvmRuntimeVersionsConsistencyChecker {
         val runtimeJarsInfo = collectRuntimeJarsInfo(classpathJarRoots)
         if (runtimeJarsInfo.jars.isEmpty()) return
 
-        val languageVersionSettings = configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS)
-        val apiVersion = languageVersionSettings?.apiVersion?.version ?: CURRENT_COMPILER_VERSION
+        val languageVersionSettings = configuration.languageVersionSettings
+        val apiVersion = languageVersionSettings.apiVersion.version
 
         val consistency = checkCompilerClasspathConsistency(messageCollector, apiVersion, runtimeJarsInfo)
         if (consistency is ClasspathConsistency.InconsistentWithApiVersion) {
@@ -137,29 +119,20 @@ object JvmRuntimeVersionsConsistencyChecker {
 
             val actualApi = ApiVersion.parse(actualRuntimeVersion.toString())
             if (actualApi != null) {
-                val newSettings = if (languageVersionSettings == null) {
-                    LanguageVersionSettingsImpl(
-                            LanguageVersionSettingsImpl.DEFAULT.languageVersion,
-                            actualApi,
-                            listOf(LanguageFeature.WarnOnCoroutines)
-                    )
-                }
-                else {
-                    val inferredApiVersion =
-                            if (@Suppress("DEPRECATION") languageVersionSettings.isApiVersionExplicit)
-                                languageVersionSettings.apiVersion
-                            else
-                                minOf(languageVersionSettings.apiVersion, actualApi)
+                val inferredApiVersion =
+                        if (@Suppress("DEPRECATION") languageVersionSettings.isApiVersionExplicit)
+                            languageVersionSettings.apiVersion
+                        else
+                            minOf(languageVersionSettings.apiVersion, actualApi)
 
-                    // "minOf" is needed in case when API version was inferred from language version and it's older than actualApi.
-                    // For example, in "kotlinc-1.2 -language-version 1.0 -cp kotlin-runtime-1.1.jar" we should still infer API = 1.0
-                    LanguageVersionSettingsImpl(
-                            languageVersionSettings.languageVersion,
-                            inferredApiVersion,
-                            languageVersionSettings.additionalFeatures,
-                            isApiVersionExplicit = false
-                    )
-                }
+                // "minOf" is needed in case when API version was inferred from language version and it's older than actualApi.
+                // For example, in "kotlinc-1.2 -language-version 1.0 -cp kotlin-runtime-1.1.jar" we should still infer API = 1.0
+                val newSettings = LanguageVersionSettingsImpl(
+                        languageVersionSettings.languageVersion,
+                        inferredApiVersion,
+                        languageVersionSettings.additionalFeatures,
+                        isApiVersionExplicit = false
+                )
 
                 messageCollector.issue(null, "Old runtime has been found in the classpath. " +
                                              "Initial language version settings: $languageVersionSettings. " +
@@ -228,10 +201,10 @@ object JvmRuntimeVersionsConsistencyChecker {
     }
 
     private fun checkNotNewerThanCompiler(messageCollector: MessageCollector, jar: KotlinLibraryFile): Boolean {
-        if (jar.version > CURRENT_COMPILER_VERSION) {
+        if (jar.version > ApiVersion.LATEST.version) {
             messageCollector.issue(
                     jar.file,
-                    "Runtime JAR file has version ${jar.version} which is newer than compiler version $CURRENT_COMPILER_VERSION",
+                    "Runtime JAR file has version ${jar.version} which is newer than compiler version ${ApiVersion.LATEST.version}",
                     CompilerMessageSeverity.ERROR
             )
             return true

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -67,7 +67,8 @@ import org.jetbrains.kotlin.cli.common.CliModuleVisibilityManagerImpl
 import org.jetbrains.kotlin.cli.common.KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING
 import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
 import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot

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

@@ -19,10 +19,10 @@ 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
+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,7 +84,7 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
 
         val configuration = CompilerConfiguration().apply {
             val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
-            put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project))
+            languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
 
             val platform = languageSettingsProvider.getTargetPlatform(moduleInfo)
             if (platform is JvmTarget) {

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

@@ -24,10 +24,9 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.builtins.JvmBuiltInsPackageFragmentProvider
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ContextForNewModule
@@ -136,13 +135,10 @@ object TopDownAnalyzerFacadeForJVM {
         val sourceScope = if (separateModules) sourceModuleSearchScope else GlobalSearchScope.allScope(project)
         val moduleClassResolver = SourceOrBinaryModuleClassResolver(sourceScope)
 
-        val languageVersionSettings =
-                configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
-
         val optionalBuiltInsModule =
                 if (configuration.getBoolean(JVMConfigurationKeys.ADD_BUILT_INS_FROM_COMPILER_TO_DEPENDENCIES)) {
                     if (createBuiltInsFromModule)
-                        JvmBuiltIns(storageManager).apply { initialize(module, languageVersionSettings) }.builtInsModule
+                        JvmBuiltIns(storageManager).apply { initialize(module, configuration.languageVersionSettings) }.builtInsModule
                     else module.builtIns.builtInsModule
                 }
                 else null
@@ -258,7 +254,7 @@ object TopDownAnalyzerFacadeForJVM {
     fun createContextWithSealedModule(project: Project, configuration: CompilerConfiguration): MutableModuleContext =
             createModuleContext(project, configuration, false).apply {
                 setDependencies(module, module.builtIns.builtInsModule)
-                (module.builtIns as JvmBuiltIns).initialize(module, configuration.get(LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT))
+                (module.builtIns as JvmBuiltIns).initialize(module, configuration.languageVersionSettings)
             }
 
     private fun createModuleContext(

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

@@ -50,9 +50,9 @@ import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmen
  */
 object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
     private val compilerConfiguration = CompilerConfiguration().apply {
-        put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl(
+        languageVersionSettings = LanguageVersionSettingsImpl(
                 LanguageVersion.LATEST, ApiVersion.LATEST, setOf(LanguageFeature.MultiPlatformProjects)
-        ))
+        )
     }
 
     private class SourceModuleInfo(

compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.kt

@@ -29,3 +29,7 @@ object CommonConfigurationKeys {
     @JvmField
     val MODULE_NAME = CompilerConfigurationKey<String>("module name")
 }
+
+var CompilerConfiguration.languageVersionSettings: LanguageVersionSettings
+    get() = get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+    set(value) = put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, value)

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

@@ -16,9 +16,8 @@
 
 package org.jetbrains.kotlin.frontend.di
 
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
@@ -69,7 +68,7 @@ fun StorageComponentContainer.configureModule(
 
 fun StorageComponentContainer.configureCommon(configuration: CompilerConfiguration) {
     useInstance(configuration)
-    useInstance(configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT))
+    useInstance(configuration.languageVersionSettings)
 }
 
 fun createContainerForBodyResolve(

compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt

@@ -19,14 +19,11 @@ package org.jetbrains.kotlin.resolve
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 
 class CompilerDeserializationConfiguration(configuration: CompilerConfiguration) : DeserializationConfiguration {
-    private val languageVersionSettings =
-            configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
-
-    override val typeAliasesAllowed = languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
+    override val typeAliasesAllowed = configuration.languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
 
     override val skipMetadataVersionCheck = configuration.getBoolean(CommonConfigurationKeys.SKIP_METADATA_VERSION_CHECK)
 }

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

@@ -18,10 +18,9 @@ package org.jetbrains.kotlin.types.expressions
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -94,7 +93,7 @@ class LocalClassifierAnalyzer(
                         typeResolver,
                         annotationResolver,
                         supertypeLoopChecker,
-                        compilerConfiguration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT),
+                        compilerConfiguration.languageVersionSettings,
                         SyntheticResolveExtension.getInstance(project),
                         delegationFilter
                 )

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

@@ -24,8 +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.LANGUAGE_VERSION_SETTINGS
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.SimpleGlobalContext
@@ -261,7 +261,9 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
 
         val configuration =
                 if (languageVersionSettings != null)
-                    environment.configuration.copy().apply { put(LANGUAGE_VERSION_SETTINGS, languageVersionSettings) }
+                    environment.configuration.copy().apply {
+                        this.languageVersionSettings = languageVersionSettings
+                    }
                 else
                     environment.configuration
 

compiler/tests-common/org/jetbrains/kotlin/codegen/CodegenTestCase.java

@@ -164,8 +164,10 @@ public abstract class CodegenTestCase extends KtUsefulTestCase {
         }
 
         if (explicitLanguageVersion != null) {
-             configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS,
-                               new LanguageVersionSettingsImpl(explicitLanguageVersion, ApiVersion.createByLanguageVersion(explicitLanguageVersion)));
+            CommonConfigurationKeysKt.setLanguageVersionSettings(
+                    configuration,
+                    new LanguageVersionSettingsImpl(explicitLanguageVersion, ApiVersion.createByLanguageVersion(explicitLanguageVersion))
+            );
         }
 
         updateConfigurationWithFlags(configuration, kotlinConfigurationFlags);