Inject JvmTarget into some JVM-specific call checkers

This makes it possible to drop CompilerConfiguration from
CallCheckerContext, which in turn helps to avoid passing the entire
CompilerConfiguration instance through front-end

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

@@ -20,6 +20,7 @@ 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.JvmTarget
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.*
@@ -87,11 +88,12 @@ fun createContainerForLazyResolveWithJava(
         targetEnvironment: TargetEnvironment,
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
+        jvmTarget: JvmTarget,
         compilerConfiguration: CompilerConfiguration,
         useBuiltInsProvider: Boolean,
         useLazyResolve: Boolean
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
-    configureModule(moduleContext, JvmPlatform, bindingTrace)
+    configureModule(moduleContext, JvmPlatform, jvmTarget, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker)
 
     useInstance(packagePartProvider)
@@ -123,10 +125,11 @@ fun createContainerForTopDownAnalyzerForJvm(
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
         moduleClassResolver: ModuleClassResolver,
+        jvmTarget: JvmTarget,
         compilerConfiguration: CompilerConfiguration
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
-        CompilerEnvironment, lookupTracker, packagePartProvider, compilerConfiguration,
+        CompilerEnvironment, lookupTracker, packagePartProvider, jvmTarget, compilerConfiguration,
         useBuiltInsProvider = true, useLazyResolve = false
 )
 

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

@@ -82,15 +82,12 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
             resolverForModule.componentProvider.get<JavaDescriptorResolver>()
         }
 
+        val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
+        val jvmTarget = languageSettingsProvider.getTargetPlatform(moduleInfo) as? JvmTarget ?: JvmTarget.JVM_1_6
+
         val configuration = CompilerConfiguration().apply {
-            val languageSettingsProvider = LanguageSettingsProvider.getInstance(project)
             languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
-
-            val platform = languageSettingsProvider.getTargetPlatform(moduleInfo)
-            if (platform is JvmTarget) {
-                put(JVMConfigurationKeys.JVM_TARGET, platform)
-            }
-
+            put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
             isReadOnly = true
         }
 
@@ -105,6 +102,7 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 targetEnvironment,
                 LookupTracker.DO_NOTHING,
                 packagePartProvider,
+                jvmTarget,
                 configuration,
                 useBuiltInsProvider = false, // TODO: load built-ins from module dependencies in IDE
                 useLazyResolve = true

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

@@ -23,10 +23,7 @@ import com.intellij.psi.search.DelegatingGlobalSearchScope
 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.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ContextForNewModule
@@ -135,6 +132,8 @@ object TopDownAnalyzerFacadeForJVM {
         val sourceScope = if (separateModules) sourceModuleSearchScope else GlobalSearchScope.allScope(project)
         val moduleClassResolver = SourceOrBinaryModuleClassResolver(sourceScope)
 
+        val jvmTarget = configuration.get(JVMConfigurationKeys.JVM_TARGET) ?: JvmTarget.JVM_1_6
+
         val optionalBuiltInsModule =
                 if (configuration.getBoolean(JVMConfigurationKeys.ADD_BUILT_INS_FROM_COMPILER_TO_DEPENDENCIES)) {
                     if (createBuiltInsFromModule)
@@ -154,7 +153,7 @@ object TopDownAnalyzerFacadeForJVM {
 
             val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
                     dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker,
-                    packagePartProvider(dependencyScope), moduleClassResolver, configuration
+                    packagePartProvider(dependencyScope), moduleClassResolver, jvmTarget, configuration
             )
 
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(dependenciesContainer, null) }
@@ -181,7 +180,7 @@ object TopDownAnalyzerFacadeForJVM {
         // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker,
-                partProvider, moduleClassResolver, configuration
+                partProvider, moduleClassResolver, jvmTarget, configuration
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get<DeserializationConfiguration>()

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

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.resolve.jvm.checkers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassOrPackageFragmentDescriptor
@@ -34,8 +33,7 @@ import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedCallableMemberDescriptor
 
-class InlinePlatformCompatibilityChecker: CallChecker {
-
+class InlinePlatformCompatibilityChecker(val jvmTarget: JvmTarget) : CallChecker {
     private val doCheck = doCheck()
 
     override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
@@ -61,15 +59,17 @@ class InlinePlatformCompatibilityChecker: CallChecker {
         val propertyOrFun = DescriptorUtils.getDirectMember(resultingDescriptor)
         val inliningBytecodeVersion = getBytecodeVersionIfDeserializedDescriptor(propertyOrFun) ?: return
 
-        val compilingTarget = context.compilerConfiguration[JVMConfigurationKeys.JVM_TARGET] ?: JvmTarget.DEFAULT
-        val compilingBytecodeVersion = compilingTarget.bytecodeVersion
+        val compilingBytecodeVersion = jvmTarget.bytecodeVersion
         if (compilingBytecodeVersion < inliningBytecodeVersion) {
-            context.trace.report(ErrorsJvm.INLINE_FROM_HIGHER_PLATFORM.on(reportOn, JvmTarget.getDescription(inliningBytecodeVersion), JvmTarget.getDescription(compilingBytecodeVersion)))
+            context.trace.report(ErrorsJvm.INLINE_FROM_HIGHER_PLATFORM.on(
+                    reportOn,
+                    JvmTarget.getDescription(inliningBytecodeVersion),
+                    JvmTarget.getDescription(compilingBytecodeVersion)
+            ))
         }
     }
 
     companion object {
-
         fun doCheck() = "true" != System.getProperty("kotlin.skip.bytecode.version.check")
 
         fun getBytecodeVersionIfDeserializedDescriptor(funOrProperty: DeclarationDescriptor): Int? {
@@ -89,4 +89,3 @@ class InlinePlatformCompatibilityChecker: CallChecker {
         }
     }
 }
-

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

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.resolve.jvm.checkers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
@@ -31,10 +30,10 @@ import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
-class InterfaceDefaultMethodCallChecker : CallChecker {
+class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker {
 
     override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
-        val supportDefaults = context.compilerConfiguration.get(JVMConfigurationKeys.JVM_TARGET) == JvmTarget.JVM_1_8
+        val supportDefaults = jvmTarget == JvmTarget.JVM_1_8
 
         val descriptor = resolvedCall.resultingDescriptor as? FunctionDescriptor ?: return
 
@@ -63,4 +62,4 @@ class InterfaceDefaultMethodCallChecker : CallChecker {
             }
         }
     }
-}
+}

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

@@ -21,10 +21,8 @@ import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.resolve.PlatformConfigurator
-import org.jetbrains.kotlin.resolve.calls.checkers.InlineCheckerWrapper
 import org.jetbrains.kotlin.resolve.calls.checkers.ReifiedTypeParameterSubstitutionChecker
 import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker
-import org.jetbrains.kotlin.resolve.checkers.MissingDependencyClassChecker
 import org.jetbrains.kotlin.resolve.jvm.*
 import org.jetbrains.kotlin.resolve.jvm.checkers.*
 import org.jetbrains.kotlin.synthetic.JavaSyntheticConstructorsProvider
@@ -50,14 +48,12 @@ object JvmPlatformConfigurator : PlatformConfigurator(
 
         additionalCallCheckers = listOf(
                 JavaAnnotationCallChecker(),
-                InterfaceDefaultMethodCallChecker(),
                 JavaClassOnCompanionChecker(),
                 ProtectedInSuperClassCompanionCallChecker(),
                 UnsupportedSyntheticCallableReferenceChecker(),
                 SuperCallWithDefaultArgumentsChecker(),
                 ProtectedSyntheticExtensionCallChecker,
-                ReifiedTypeParameterSubstitutionChecker(),
-                InlinePlatformCompatibilityChecker()
+                ReifiedTypeParameterSubstitutionChecker()
         ),
 
         additionalTypeCheckers = listOf(
@@ -88,6 +84,8 @@ object JvmPlatformConfigurator : PlatformConfigurator(
     override fun configureModuleComponents(container: StorageComponentContainer) {
         container.useImpl<JvmReflectionAPICallChecker>()
         container.useImpl<JavaSyntheticScopes>()
+        container.useImpl<InterfaceDefaultMethodCallChecker>()
+        container.useImpl<InlinePlatformCompatibilityChecker>()
         container.useInstance(JavaSyntheticConstructorsProvider)
         container.useInstance(JvmTypeSpecificityComparator)
     }

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

@@ -51,7 +51,7 @@ import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmen
 object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
     private val compilerConfiguration = CompilerConfiguration().apply {
         languageVersionSettings = LanguageVersionSettingsImpl(
-                LanguageVersion.LATEST, ApiVersion.LATEST, setOf(LanguageFeature.MultiPlatformProjects)
+                LanguageVersion.LATEST, ApiVersion.LATEST, additionalFeatures = setOf(LanguageFeature.MultiPlatformProjects)
         )
     }
 
@@ -128,7 +128,7 @@ object DefaultAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
             targetEnvironment: TargetEnvironment,
             packagePartProvider: PackagePartProvider
     ): StorageComponentContainer = createContainer("ResolveCommonCode", targetPlatform) {
-        configureModule(moduleContext, targetPlatform, bindingTrace)
+        configureModule(moduleContext, targetPlatform, TargetPlatformVersion.NoVersion, bindingTrace)
 
         useInstance(moduleContentScope)
         useInstance(LookupTracker.DO_NOTHING)

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

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.frontend.di
 
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
@@ -36,7 +37,9 @@ import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder
 import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
 
 fun StorageComponentContainer.configureModule(
-        moduleContext: ModuleContext, platform: TargetPlatform
+        moduleContext: ModuleContext,
+        platform: TargetPlatform,
+        platformVersion: TargetPlatformVersion
 ) {
     useInstance(moduleContext)
     useInstance(moduleContext.module)
@@ -45,6 +48,7 @@ fun StorageComponentContainer.configureModule(
     useInstance(moduleContext.module.builtIns)
 
     useInstance(platform)
+    useInstance(platformVersion)
 
     platform.platformConfigurator.configureModuleComponents(this)
 
@@ -60,9 +64,12 @@ private fun StorageComponentContainer.configurePlatformIndependentComponents() {
 }
 
 fun StorageComponentContainer.configureModule(
-        moduleContext: ModuleContext, platform: TargetPlatform, trace: BindingTrace
+        moduleContext: ModuleContext,
+        platform: TargetPlatform,
+        platformVersion: TargetPlatformVersion,
+        trace: BindingTrace
 ) {
-    configureModule(moduleContext, platform)
+    configureModule(moduleContext, platform, platformVersion)
     useInstance(trace)
 }
 
@@ -76,9 +83,10 @@ fun createContainerForBodyResolve(
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         statementFilter: StatementFilter,
+        targetPlatformVersion: TargetPlatformVersion,
         compilerConfiguration: CompilerConfiguration
 ): StorageComponentContainer = createContainer("BodyResolve", platform) {
-    configureModule(moduleContext, platform, bindingTrace)
+    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
     useInstance(statementFilter)
 
@@ -95,9 +103,10 @@ fun createContainerForLazyBodyResolve(
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         bodyResolveCache: BodyResolveCache,
+        targetPlatformVersion: TargetPlatformVersion,
         compilerConfiguration: CompilerConfiguration
 ): StorageComponentContainer = createContainer("LazyBodyResolve", platform) {
-    configureModule(moduleContext, platform, bindingTrace)
+    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
     useInstance(LookupTracker.DO_NOTHING)
     useInstance(kotlinCodeAnalyzer)
@@ -113,11 +122,12 @@ fun createContainerForLazyLocalClassifierAnalyzer(
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
         lookupTracker: LookupTracker,
+        targetPlatformVersion: TargetPlatformVersion,
         compilerConfiguration: CompilerConfiguration,
         statementFilter: StatementFilter,
         localClassDescriptorHolder: LocalClassDescriptorHolder
 ): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", platform) {
-    configureModule(moduleContext, platform, bindingTrace)
+    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
     useInstance(localClassDescriptorHolder)
     useInstance(lookupTracker)
@@ -142,10 +152,11 @@ fun createContainerForLazyResolve(
         declarationProviderFactory: DeclarationProviderFactory,
         bindingTrace: BindingTrace,
         platform: TargetPlatform,
+        targetPlatformVersion: TargetPlatformVersion,
         targetEnvironment: TargetEnvironment,
         compilerConfiguration: CompilerConfiguration
 ): StorageComponentContainer = createContainer("LazyResolve", platform) {
-    configureModule(moduleContext, platform, bindingTrace)
+    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
 
     useInstance(declarationProviderFactory)
     useInstance(LookupTracker.DO_NOTHING)
@@ -166,6 +177,7 @@ fun createLazyResolveSession(moduleContext: ModuleContext, files: Collection<KtF
                 FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
                 BindingTraceContext(),
                 TargetPlatform.Default,
+                TargetPlatformVersion.NoVersion,
                 CompilerEnvironment,
                 CompilerConfiguration.EMPTY
         ).get<ResolveSession>()

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

@@ -20,6 +20,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.GlobalContext
@@ -62,6 +63,7 @@ class LocalClassifierAnalyzer(
         private val platform: TargetPlatform,
         private val lookupTracker: LookupTracker,
         private val supertypeLoopChecker: SupertypeLoopChecker,
+        private val targetPlatformVersion: TargetPlatformVersion,
         private val compilerConfiguration: CompilerConfiguration,
         private val delegationFilter: DelegationFilter
 ) {
@@ -79,6 +81,7 @@ class LocalClassifierAnalyzer(
                 context.trace,
                 platform,
                 lookupTracker,
+                targetPlatformVersion,
                 compilerConfiguration,
                 context.statementFilter,
                 LocalClassDescriptorHolder(
@@ -160,10 +163,9 @@ class LocalClassDescriptorHolder(
                         override val languageVersionSettings = this@LocalClassDescriptorHolder.languageVersionSettings
                         override val syntheticResolveExtension = this@LocalClassDescriptorHolder.syntheticResolveExtension
                         override val delegationFilter: DelegationFilter = this@LocalClassDescriptorHolder.delegationFilter
-                    }
-                    ,
+                    },
                     containingDeclaration,
-                    classOrObject.getNameAsSafeName(),
+                    classOrObject.nameAsSafeName,
                     KtClassInfoUtil.createClassLikeInfo(classOrObject),
                     classOrObject.hasModifier(KtTokens.EXTERNAL_KEYWORD)
             )

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

@@ -24,6 +24,7 @@ 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.JvmTarget
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.config.languageVersionSettings
@@ -316,6 +317,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                 LookupTracker.DO_NOTHING,
                 JvmPackagePartProvider(environment, moduleContentScope),
                 moduleClassResolver,
+                JvmTarget.JVM_1_6,
                 configuration
         )
         container.initJvmBuiltInsForTopDownAnalysis()

compiler/tests-common/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -21,6 +21,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -61,6 +62,7 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
                 FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 JvmPlatform,
+                JvmTarget.JVM_1_6,
                 targetEnvironment,
                 CompilerConfiguration.EMPTY
         )

compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.tests.di
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.getValue
 import org.jetbrains.kotlin.container.useImpl
@@ -37,7 +38,7 @@ import org.jetbrains.kotlin.types.expressions.FakeCallResolver
 
 fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
     return ContainerForTests(createContainer("Tests", JvmPlatform) {
-        configureModule(ModuleContext(module, project), JvmPlatform)
+        configureModule(ModuleContext(module, project), JvmPlatform, JvmTarget.JVM_1_6)
         useInstance(LookupTracker.DO_NOTHING)
         configureCommon(CompilerConfiguration.EMPTY)
         useImpl<ExpressionTypingServices>()

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

@@ -20,6 +20,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.caches.resolve.LibraryModuleInfo
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
@@ -66,6 +67,7 @@ object JsAnalyzerFacade : AnalyzerFacade<PlatformAnalysisParameters>() {
                 declarationProviderFactory,
                 BindingTraceContext(),
                 JsPlatform,
+                TargetPlatformVersion.NoVersion,
                 targetEnvironment,
                 configuration
         )

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

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.project.createCompilerConfiguration
+import org.jetbrains.kotlin.idea.project.jvmTarget
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import org.jetbrains.kotlin.resolve.*
@@ -173,6 +174,7 @@ private object KotlinResolveDataProvider {
                     trace,
                     targetPlatform,
                     componentProvider.get<BodyResolveCache>(),
+                    analyzableElement.jvmTarget,
                     analyzableElement.createCompilerConfiguration()
             ).get<LazyTopDownAnalyzer>()
 

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

@@ -144,13 +144,7 @@ private fun getExtraLanguageFeatures(
 
 fun KtElement.createCompilerConfiguration(): CompilerConfiguration = CompilerConfiguration().apply {
     languageVersionSettings = this@createCompilerConfiguration.languageVersionSettings
-
-    val module = ModuleUtilCore.findModuleForPsiElement(this@createCompilerConfiguration)
-    val platform = module?.targetPlatform?.version
-    if (platform is JvmTarget) {
-        put(JVMConfigurationKeys.JVM_TARGET, platform)
-    }
-
+    put(JVMConfigurationKeys.JVM_TARGET, jvmTarget)
     isReadOnly = true
 }
 
@@ -161,3 +155,6 @@ val KtElement.languageVersionSettings: LanguageVersionSettings
         }
         return ModuleUtilCore.findModuleForPsiElement(this)?.languageVersionSettings ?: LanguageVersionSettingsImpl.DEFAULT
     }
+
+val KtElement.jvmTarget: JvmTarget
+    get() = ModuleUtilCore.findModuleForPsiElement(this)?.targetPlatform?.version as? JvmTarget ?: JvmTarget.DEFAULT

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

@@ -588,6 +588,7 @@ class ResolveElementCache(
                 trace,
                 targetPlatform,
                 statementFilter,
+                file.jvmTarget,
                 file.createCompilerConfiguration()
         ).get<BodyResolver>()
     }

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

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.frontend.js.di
 
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
@@ -42,7 +43,7 @@ fun createTopDownAnalyzerForJs(
         compilerConfiguration: CompilerConfiguration
 ): LazyTopDownAnalyzer {
     val storageComponentContainer = createContainer("TopDownAnalyzerForJs", JsPlatform) {
-        configureModule(moduleContext, JsPlatform, bindingTrace)
+        configureModule(moduleContext, JsPlatform, TargetPlatformVersion.NoVersion, bindingTrace)
 
         useInstance(declarationProviderFactory)
         useImpl<FileScopeProviderImpl>()