Drop JvmMetadataVersion.skipCheck, support this correctly

Pass the value of this flag via DeserializationConfiguration

compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt

@@ -40,7 +40,7 @@ private fun Iterable<PackageParts>.addCompiledParts(state: GenerationState): Lis
     val incrementalCache = state.incrementalCacheForThisTarget ?: return this.toList()
     val moduleMappingData = incrementalCache.getModuleMappingData() ?: return this.toList()
 
-    val mapping = ModuleMapping.create(moduleMappingData, "<incremental>")
+    val mapping = ModuleMapping.create(moduleMappingData, "<incremental>", state.deserializationConfiguration)
 
     incrementalCache.getObsoletePackageParts().forEach { internalName ->
         val qualifier = internalName.substringBeforeLast('/', "").replace('/', '.')

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

@@ -41,12 +41,10 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
-import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.BindingTraceFilter
-import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.org.objectweb.asm.Opcodes
 import java.io.File
 
@@ -94,6 +92,7 @@ class GenerationState @JvmOverloads constructor(
     val incrementalCacheForThisTarget: IncrementalCache?
     val packagesWithObsoleteParts: Set<FqName>
     val obsoleteMultifileClasses: List<FqName>
+    val deserializationConfiguration: DeserializationConfiguration = CompilerDeserializationConfiguration(configuration)
 
     init {
         val icComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)

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

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.compiler.plugin.PluginCliOptionProcessingException
 import org.jetbrains.kotlin.compiler.plugin.cliPluginUsageString
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.script.KotlinScriptDefinitionFromAnnotatedTemplate
 import org.jetbrains.kotlin.script.StandardScriptDefinition
@@ -114,10 +113,6 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             return ExitCode.OK
         }
 
-        if (arguments.skipMetadataVersionCheck) {
-            JvmMetadataVersion.skipCheck = true
-        }
-
         if (arguments.includeRuntime) {
             configuration.put(JVMConfigurationKeys.INCLUDE_RUNTIME, true)
         }
@@ -317,6 +312,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             configuration.put(JVMConfigurationKeys.DISABLE_OPTIMIZATION, arguments.noOptimize)
             configuration.put(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, arguments.inheritMultifileParts)
             configuration.put(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK, arguments.skipRuntimeVersionCheck)
+            configuration.put(CommonConfigurationKeys.SKIP_METADATA_VERSION_CHECK, arguments.skipMetadataVersionCheck)
             configuration.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
             configuration.put(CLIConfigurationKeys.REPORT_PERF, arguments.reportPerf)
             configuration.put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)

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

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.PackageParts
+import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
 import java.io.EOFException
 
 class JvmPackagePartProvider(
@@ -32,6 +33,8 @@ class JvmPackagePartProvider(
 ) : PackagePartProvider {
     private data class ModuleMappingInfo(val root: VirtualFile, val mapping: ModuleMapping)
 
+    private val deserializationConfiguration = CompilerDeserializationConfiguration(env.configuration)
+
     private val notLoadedRoots by lazy(LazyThreadSafetyMode.NONE) {
         env.configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS)
                 .filterIsInstance<JvmClasspathRoot>()
@@ -96,7 +99,7 @@ class JvmPackagePartProvider(
             val moduleFiles = metaInf.children.filter { it.name.endsWith(ModuleMapping.MAPPING_FILE_EXT) }
             for (moduleFile in moduleFiles) {
                 val mapping = try {
-                    ModuleMapping.create(moduleFile.contentsToByteArray(), moduleFile.toString())
+                    ModuleMapping.create(moduleFile.contentsToByteArray(), moduleFile.toString(), deserializationConfiguration)
                 }
                 catch (e: EOFException) {
                     throw RuntimeException("Error on reading package parts for '$packageFqName' package in '$moduleFile', " +

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt

@@ -19,18 +19,19 @@ package org.jetbrains.kotlin.load.kotlin.incremental
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
-import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
-import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.storage.StorageManager
 
-internal class IncrementalPackagePartProvider private constructor(
+internal class IncrementalPackagePartProvider(
         private val parent: PackagePartProvider,
         incrementalCaches: List<IncrementalCache>,
         storageManager: StorageManager
 ) : PackagePartProvider {
+    lateinit var deserializationConfiguration: DeserializationConfiguration
+
     private val moduleMappings = storageManager.createLazyValue {
         incrementalCaches.map { cache ->
-            ModuleMapping.create(cache.getModuleMappingData(), "<incremental>")
+            ModuleMapping.create(cache.getModuleMappingData(), "<incremental>", deserializationConfiguration)
         }
     }
 
@@ -41,19 +42,4 @@ internal class IncrementalPackagePartProvider private constructor(
 
     // TODO
     override fun findMetadataPackageParts(packageFqName: String): List<String> = TODO()
-
-    companion object {
-        @JvmStatic
-        fun create(
-                parent: PackagePartProvider,
-                targets: List<TargetId>?,
-                incrementalCompilationComponents: IncrementalCompilationComponents?,
-                storageManager: StorageManager
-        ): PackagePartProvider {
-            if (targets == null || incrementalCompilationComponents == null) return parent
-
-            val incrementalCaches = targets.map { incrementalCompilationComponents.getIncrementalCache(it) }
-            return IncrementalPackagePartProvider(parent, incrementalCaches, storageManager)
-        }
-    }
 }

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

@@ -63,6 +63,7 @@ import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtens
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.storage.StorageManager
 import java.util.*
 
@@ -173,18 +174,22 @@ object TopDownAnalyzerFacadeForJVM {
         }
         else null
 
+        val partProvider = packagePartProvider(sourceScope).let { fragment ->
+            if (targetIds == null || incrementalComponents == null) fragment
+            else IncrementalPackagePartProvider(fragment, targetIds.map(incrementalComponents::getIncrementalCache), storageManager)
+        }
+
         // Note that it's necessary to create container for sources _after_ creation of container for dependencies because
         // CliLightClassGenerationSupport#initialize is invoked when container is created, so only the last module descriptor is going
         // to be stored in CliLightClassGenerationSupport, and it better be the source one (otherwise light classes would not be found)
         // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker,
-                IncrementalPackagePartProvider.create(
+                partProvider, languageVersionSettings, moduleClassResolver, configuration
-                        packagePartProvider(sourceScope), targetIds, incrementalComponents, storageManager
-                ),
-                languageVersionSettings, moduleClassResolver, configuration
         ).apply {
             initJvmBuiltInsForTopDownAnalysis(module, languageVersionSettings)
+            (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get<DeserializationConfiguration>()
+
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(this, null) }
         }
 

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

@@ -23,6 +23,9 @@ public class CommonConfigurationKeys {
     public static final CompilerConfigurationKey<LanguageVersionSettings> LANGUAGE_VERSION_SETTINGS =
             CompilerConfigurationKey.create("language version settings");
 
+    public static final CompilerConfigurationKey<Boolean> SKIP_METADATA_VERSION_CHECK =
+            CompilerConfigurationKey.create("skip metadata version check");
+
     public static final CompilerConfigurationKey<Boolean> DISABLE_INLINE =
             CompilerConfigurationKey.create("disable inline");
 

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.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
@@ -144,7 +145,9 @@ fun createContainerForLazyResolve(
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(languageVersionSettings)
     //TODO: need to propagate full CompilerConfiguration to frontend
-    useInstance(CompilerConfiguration.EMPTY)
+    useInstance(CompilerConfiguration().apply {
+        put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
+    })
 
     useImpl<FileScopeProviderImpl>()
     useImpl<CompilerDeserializationConfiguration>()

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

@@ -16,11 +16,17 @@
 
 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.LanguageVersionSettings
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 
-class CompilerDeserializationConfiguration(private val languageVersionSettings: LanguageVersionSettings) : DeserializationConfiguration {
+class CompilerDeserializationConfiguration(configuration: CompilerConfiguration) : DeserializationConfiguration {
-    override val typeAliasesAllowed: Boolean
+    private val languageVersionSettings =
-        get() = languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
+            configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+
+    override val typeAliasesAllowed = languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
+
+    override val skipMetadataVersionCheck = configuration.getBoolean(CommonConfigurationKeys.SKIP_METADATA_VERSION_CHECK)
 }

compiler/tests/org/jetbrains/kotlin/codegen/JvmPackageTableTest.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.cli.AbstractCliTest
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 import java.io.File
@@ -38,7 +39,10 @@ class JvmPackageTableTest : KtUsefulTestCase() {
         System.err.println(output) // normally output is empty
         assertEquals("Compilation should complete successfully", ExitCode.OK, exitCode)
 
-        val mapping = ModuleMapping.create(File(tmpdir, "META-INF/$moduleName.${ModuleMapping.MAPPING_FILE_EXT}").readBytes(), "test")
+        val mapping = ModuleMapping.create(
+                File(tmpdir, "META-INF/$moduleName.${ModuleMapping.MAPPING_FILE_EXT}").readBytes(), "test",
+                DeserializationConfiguration.Default
+        )
         val result = buildString {
             for ((fqName, packageParts) in mapping.packageFqName2Parts) {
                 appendln(fqName)

compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java

@@ -417,14 +417,9 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
         doTestPreReleaseKotlinLibrary("library");
     }
 
-    /*
-    // This test should pass but is commented out because the compiler flag is implemented via mutation of the public field,
-    // which may cause subsequent tests to behave unexpectedly
-    // TODO: refactor and uncomment
     public void testReleaseCompilerAgainstPreReleaseLibrarySkipVersionCheck() throws Exception {
         doTestPreReleaseKotlinLibrary("library", "-Xskip-metadata-version-check");
     }
-    */
 
     public void testWrongMetadataVersion() throws Exception {
         doTestKotlinLibraryWithWrongMetadataVersion("library", null);
@@ -466,12 +461,9 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
         );
     }
 
-    /*
-    // TODO: refactor and uncomment
     public void testWrongMetadataVersionSkipVersionCheck() throws Exception {
         doTestKotlinLibraryWithWrongMetadataVersion("library", null, "-Xskip-metadata-version-check");
     }
-    */
 
     /*test source mapping generation when source info is absent*/
     public void testInlineFunWithoutDebugInfo() throws Exception {

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.serialization.deserialization.DeserializationCompone
 import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPackageMemberScope
 import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil
-import org.jetbrains.kotlin.utils.addToStdlib.check
 import javax.inject.Inject
 
 class DeserializedDescriptorResolver {
@@ -39,6 +38,9 @@ class DeserializedDescriptorResolver {
         this.components = components.components
     }
 
+    private val skipMetadataVersionCheck: Boolean
+        get() = components.configuration.skipMetadataVersionCheck
+
     fun resolveClass(kotlinClass: KotlinJvmBinaryClass): ClassDescriptor? {
         val classData = readClassData(kotlinClass) ?: return null
         return components.classDeserializer.deserializeClass(kotlinClass.classId, classData)
@@ -69,18 +71,18 @@ class DeserializedDescriptorResolver {
 
     private val KotlinJvmBinaryClass.incompatibility: IncompatibleVersionErrorData<JvmMetadataVersion>?
         get() {
-            if (classHeader.metadataVersion.isCompatible()) return null
+            if (skipMetadataVersionCheck || classHeader.metadataVersion.isCompatible()) return null
             return IncompatibleVersionErrorData(classHeader.metadataVersion, JvmMetadataVersion.INSTANCE, location, classId)
         }
 
     private val KotlinJvmBinaryClass.isPreReleaseInvisible: Boolean
-        get() = !JvmMetadataVersion.skipCheck &&
+        get() = !skipMetadataVersionCheck &&
                 !KotlinCompilerVersion.isPreRelease() &&
                 (classHeader.isPreRelease || classHeader.metadataVersion == KOTLIN_1_1_EAP_METADATA_VERSION)
 
     internal fun readData(kotlinClass: KotlinJvmBinaryClass, expectedKinds: Set<KotlinClassHeader.Kind>): Array<String>? {
         val header = kotlinClass.classHeader
-        return (header.data ?: header.incompatibleData)?.check { header.kind in expectedKinds }
+        return (header.data ?: header.incompatibleData)?.takeIf { header.kind in expectedKinds }
     }
 
     private inline fun <T : Any> parseProto(klass: KotlinJvmBinaryClass, block: () -> T): T? {
@@ -93,11 +95,12 @@ class DeserializedDescriptorResolver {
             }
         }
         catch (e: Throwable) {
-            if (!klass.classHeader.metadataVersion.isCompatible()) {
+            if (skipMetadataVersionCheck || klass.classHeader.metadataVersion.isCompatible()) {
-                // TODO: log.warn
+                throw e
-                return null
             }
-            throw e
+
+            // TODO: log.warn
+            return null
         }
     }
 

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/JvmMetadataVersion.kt

@@ -25,12 +25,9 @@ import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
 class JvmMetadataVersion(vararg numbers: Int) : BinaryVersion(*numbers) {
     // NOTE: 1.1 is incompatible with 1.0 and hence with any other version except 1.1.*
     override fun isCompatible() =
-            skipCheck || (this.major == 1 && this.minor == 1)
+            this.major == 1 && this.minor == 1
 
     companion object {
-        // TODO: this is a temporary hack which can be removed once we migrate the IDEA code from 1.0 to 1.1
-        var skipCheck: Boolean = false
-
         @JvmField
         val INSTANCE = JvmMetadataVersion(1, 1, 5)
 

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/ModuleMapping.kt

@@ -16,10 +16,10 @@
 
 package org.jetbrains.kotlin.load.kotlin
 
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.serialization.jvm.JvmPackageTable
 import java.io.ByteArrayInputStream
 import java.io.DataInputStream
-import kotlin.comparisons.nullsLast
 
 class ModuleMapping private constructor(val packageFqName2Parts: Map<String, PackageParts>, private val debugName: String) {
     fun findPackageParts(packageFqName: String): PackageParts? {
@@ -35,7 +35,11 @@ class ModuleMapping private constructor(val packageFqName2Parts: Map<String, Pac
         @JvmField
         val EMPTY: ModuleMapping = ModuleMapping(emptyMap(), "EMPTY")
 
-        fun create(bytes: ByteArray?, debugName: String?): ModuleMapping {
+        fun create(
+                bytes: ByteArray?,
+                debugName: String,
+                configuration: DeserializationConfiguration
+        ): ModuleMapping {
             if (bytes == null) {
                 return EMPTY
             }
@@ -43,7 +47,7 @@ class ModuleMapping private constructor(val packageFqName2Parts: Map<String, Pac
             val stream = DataInputStream(ByteArrayInputStream(bytes))
             val version = JvmMetadataVersion(*IntArray(stream.readInt()) { stream.readInt() })
 
-            if (version.isCompatible()) {
+            if (configuration.skipMetadataVersionCheck || version.isCompatible()) {
                 val table = JvmPackageTable.PackageTable.parseFrom(stream) ?: return EMPTY
                 val result = linkedMapOf<String, PackageParts>()
 
@@ -60,7 +64,7 @@ class ModuleMapping private constructor(val packageFqName2Parts: Map<String, Pac
                     proto.classNameList.forEach(packageParts::addMetadataPart)
                 }
 
-                return ModuleMapping(result, debugName ?: "<unknown>")
+                return ModuleMapping(result, debugName)
             }
             else {
                 // TODO: consider reporting "incompatible ABI version" error for package parts

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimePackagePartProvider.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.kotlin.reflect
 
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import java.util.concurrent.ConcurrentHashMap
 
 class RuntimePackagePartProvider(private val classLoader: ClassLoader) : PackagePartProvider {
@@ -27,7 +28,7 @@ class RuntimePackagePartProvider(private val classLoader: ClassLoader) : Package
         val mapping = try {
             val resourcePath = "META-INF/$moduleName.${ModuleMapping.MAPPING_FILE_EXT}"
             classLoader.getResourceAsStream(resourcePath)?.use { stream ->
-                ModuleMapping.create(stream.readBytes(), resourcePath)
+                ModuleMapping.create(stream.readBytes(), resourcePath, DeserializationConfiguration.Default)
             }
         }
         catch (e: Exception) {

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/DeserializationConfiguration.kt

@@ -17,6 +17,9 @@
 package org.jetbrains.kotlin.serialization.deserialization
 
 interface DeserializationConfiguration {
+    val skipMetadataVersionCheck: Boolean
+        get() = false
+
     val typeAliasesAllowed: Boolean
         get() = true
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/moduleMappingIndexes.kt

@@ -22,6 +22,7 @@ import com.intellij.util.io.IOUtil
 import com.intellij.util.io.KeyDescriptor
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.PackageParts
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import java.io.DataInput
 import java.io.DataOutput
 
@@ -77,7 +78,7 @@ object KotlinModuleMappingIndex : FileBasedIndexExtension<String, PackageParts>(
             val content = inputData.content
             val file = inputData.file
             try {
-                val moduleMapping = ModuleMapping.create(content, file.toString())
+                val moduleMapping = ModuleMapping.create(content, file.toString(), DeserializationConfiguration.Default)
                 return@DataIndexer moduleMapping.packageFqName2Parts
             }
             catch(e: Exception) {

js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java

@@ -23,7 +23,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.js.resolve.JsPlatform;
@@ -129,9 +128,7 @@ public abstract class JsConfig {
         );
 
         JsModuleDescriptor<PackageFragmentProvider> rawDescriptor = KotlinJavascriptSerializationUtil.readModule(
-                metadata.getBody(), storageManager, moduleDescriptor, new CompilerDeserializationConfiguration(
+                metadata.getBody(), storageManager, moduleDescriptor, new CompilerDeserializationConfiguration(configuration)
-                        configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
-                )
         );
 
         PackageFragmentProvider provider = rawDescriptor.getData();