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

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

@@ -20,10 +20,8 @@ import com.intellij.openapi.roots.OrderRootType
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.PathUtil
 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
@@ -61,8 +59,7 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
 
         // TODO: deduplicate this with JvmAnalyzerFacade
         val configuration = CompilerConfiguration().apply {
-            val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
-            put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project))
+            languageVersionSettings = LanguageSettingsProvider.getInstance(project).getLanguageVersionSettings(moduleInfo, project)
             isReadOnly = true
         }
 

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

@@ -144,7 +144,7 @@ private fun getExtraLanguageFeatures(
 }
 
 fun KtElement.createCompilerConfiguration(): CompilerConfiguration = CompilerConfiguration().apply {
-    put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
+    languageVersionSettings = this@createCompilerConfiguration.languageVersionSettings
     isReadOnly = true
 }
 

idea/src/org/jetbrains/kotlin/idea/internal/KotlinBytecodeToolWindow.java

@@ -134,8 +134,7 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable {
                 configuration.put(JVMConfigurationKeys.IR, true);
             }
 
-            LanguageVersionSettings languageVersionSettings = PlatformKt.getLanguageVersionSettings(ktFile);
-            configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings);
+            CommonConfigurationKeysKt.setLanguageVersionSettings(configuration, PlatformKt.getLanguageVersionSettings(ktFile));
 
             return getBytecodeForFile(ktFile, configuration);
         }

idea/src/org/jetbrains/kotlin/idea/internal/KotlinDecompilerServiceImpl.kt

@@ -25,8 +25,8 @@ import org.jetbrains.java.decompiler.main.decompiler.BaseDecompiler
 import org.jetbrains.java.decompiler.main.extern.IBytecodeProvider
 import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences
 import org.jetbrains.java.decompiler.main.extern.IResultSaver
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.idea.actions.canBeDecompiledToJava
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.psi.KtFile
@@ -47,7 +47,7 @@ class KotlinDecompilerServiceImpl : KotlinDecompilerService {
         )
 
         val bytecodeProvider = IBytecodeProvider {
-            externalPath, internalPath ->
+            externalPath, _ ->
             val path = File(FileUtil.toSystemIndependentName(externalPath))
             bytecodeMap[path]?.invoke()
         }
@@ -75,7 +75,7 @@ class KotlinDecompilerServiceImpl : KotlinDecompilerService {
 
     fun bytecodeMapForSourceFile(file: KtFile): Map<File, () -> ByteArray> {
         val configuration = CompilerConfiguration().apply {
-            put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, file.languageVersionSettings)
+            languageVersionSettings = file.languageVersionSettings
         }
         val generationState = KotlinBytecodeToolWindow.compileSingleFile(file, configuration)
 

idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java

@@ -68,8 +68,10 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic
         configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true);
         configuration.put(JSConfigurationKeys.UNIT_TEST_CONFIG, true);
         if (explicitLanguageVersion != null) {
-            configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS,
-                              new LanguageVersionSettingsImpl(explicitLanguageVersion, ApiVersion.LATEST));
+            CommonConfigurationKeysKt.setLanguageVersionSettings(
+                    configuration,
+                    new LanguageVersionSettingsImpl(explicitLanguageVersion, LanguageVersionSettingsImpl.DEFAULT.getApiVersion())
+            );
         }
         return new LibrarySourcesConfig(getProject(), configuration);
     }

idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java

@@ -24,7 +24,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.*;
+import org.jetbrains.kotlin.config.CommonConfigurationKeysKt;
+import org.jetbrains.kotlin.config.CompilerConfiguration;
+import org.jetbrains.kotlin.config.LanguageVersion;
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
@@ -79,8 +82,10 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro
     protected AnalysisResult analyze(@NotNull KtFile file, @Nullable LanguageVersion explicitLanguageVersion) {
         CompilerConfiguration configuration = getEnvironment().getConfiguration();
         if (explicitLanguageVersion != null) {
-            configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS,
-                              new LanguageVersionSettingsImpl(explicitLanguageVersion, ApiVersion.LATEST));
+            CommonConfigurationKeysKt.setLanguageVersionSettings(
+                    configuration,
+                    new LanguageVersionSettingsImpl(explicitLanguageVersion, LanguageVersionSettingsImpl.DEFAULT.getApiVersion())
+            );
         }
         return JvmResolveUtil.analyze(Collections.singleton(file), getEnvironment(), configuration);
     }

idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.idea.internal
 
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.project.languageVersionSettings
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
@@ -34,19 +35,20 @@ abstract class AbstractBytecodeToolWindowTest: KotlinLightCodeInsightFixtureTest
     fun doTest(testPath: String) {
         val mainDir = File(testPath)
         val mainFileName = mainDir.name + ".kt"
-        mainDir.listFiles { file, name -> name != mainFileName }.forEach { myFixture.configureByFile(testPath + "/" + it.name) }
+        mainDir.listFiles { _, name -> name != mainFileName }.forEach { myFixture.configureByFile(testPath + "/" + it.name) }
 
         val mainFileText = File("$testPath/$mainFileName").readText()
         myFixture.configureByText(KotlinFileType.INSTANCE, mainFileText)
 
         val file = myFixture.file as KtFile
 
-        val configuration = CompilerConfiguration()
-        if (InTextDirectivesUtils.getPrefixedBoolean(mainFileText, "// INLINE:") == false) {
-            configuration.put(CommonConfigurationKeys.DISABLE_INLINE, true)
-        }
+        val configuration = CompilerConfiguration().apply {
+            if (InTextDirectivesUtils.getPrefixedBoolean(mainFileText, "// INLINE:") == false) {
+                put(CommonConfigurationKeys.DISABLE_INLINE, true)
+            }
 
-        configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, file.languageVersionSettings)
+            languageVersionSettings = file.languageVersionSettings
+        }
 
         val bytecodes = KotlinBytecodeToolWindow.getBytecodeForFile(file, configuration)
         assert(bytecodes.contains("// ================")) {

js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.js.test
 
-import org.jetbrains.kotlin.js.backend.ast.JsProgram
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.StandardFileSystems
@@ -31,6 +30,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.js.JavaScript
+import org.jetbrains.kotlin.js.backend.ast.JsProgram
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -255,8 +255,9 @@ abstract class BasicBoxTest(
         val configuration = environment.configuration.copy()
 
         configuration.put(CommonConfigurationKeys.DISABLE_INLINE, module.inliningDisabled)
-        module.languageVersion?.let {
-            configuration.put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl(it, ApiVersion.LATEST))
+        module.languageVersion?.let { languageVersion ->
+            configuration.languageVersionSettings =
+                    LanguageVersionSettingsImpl(languageVersion, LanguageVersionSettingsImpl.DEFAULT.apiVersion)
         }
 
         configuration.put(JSConfigurationKeys.LIBRARIES, LibrarySourcesConfig.JS_STDLIB + LibrarySourcesConfig.JS_KOTLIN_TEST + dependencies)