[Resolve] Make ResolversForModule less static

As consequence, remove IdePlatformKindTooling.resolverForModule, because
it became more than just field, and it duplicates similar API in
IdePlatformKindResolution anyways

compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -55,14 +55,33 @@ class CommonAnalysisParameters(
  * A facade that is used to analyze common (platform-independent) modules in multi-platform projects.
  * See [CommonPlatform]
  */
-class CommonResolverForModuleFactory(private val shouldCheckExpectActual: Boolean) : ResolverForModuleFactory() {
+class CommonResolverForModuleFactory(
+    private val platformParameters: CommonAnalysisParameters,
+    private val targetEnvironment: TargetEnvironment,
+    private val targetPlatform: TargetPlatform,
+    private val shouldCheckExpectActual: Boolean
+) : ResolverForModuleFactory() {
+    private class SourceModuleInfo(
+        override val name: Name,
+        override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>,
+        private val dependOnOldBuiltIns: Boolean
+    ) : ModuleInfo {
+        override fun dependencies() = listOf(this)
+
+        override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
+            if (dependOnOldBuiltIns) ModuleInfo.DependencyOnBuiltIns.LAST else ModuleInfo.DependencyOnBuiltIns.NONE
+
+        override val platform: TargetPlatform
+            get() = CommonPlatforms.defaultCommonPlatform
+
+        override val analyzerServices: PlatformDependentAnalyzerServices
+            get() = CommonPlatformAnalyzerServices
+    }
 
     override fun <M : ModuleInfo> createResolverForModule(
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
         moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings
     ): ResolverForModule {
@@ -90,27 +109,9 @@ class CommonResolverForModuleFactory(private val shouldCheckExpectActual: Boolea
     }
 
     companion object {
-        private class SourceModuleInfo(
-            override val name: Name,
-            override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>,
-            private val dependOnOldBuiltIns: Boolean
-        ) : ModuleInfo {
-            override fun dependencies() = listOf(this)
-
-            override fun dependencyOnBuiltIns(): ModuleInfo.DependencyOnBuiltIns =
-                if (dependOnOldBuiltIns) ModuleInfo.DependencyOnBuiltIns.LAST else ModuleInfo.DependencyOnBuiltIns.NONE
-
-            override val platform: TargetPlatform
-                get() = CommonPlatforms.defaultCommonPlatform
-
-            override val analyzerServices: PlatformDependentAnalyzerServices
-                get() = CommonPlatformAnalyzerServices
-        }
-
         fun analyzeFiles(
             files: Collection<KtFile>, moduleName: Name, dependOnBuiltIns: Boolean, languageVersionSettings: LanguageVersionSettings,
             capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap(),
-            shouldCheckExpectActual: Boolean = false,
             metadataPartProviderFactory: (ModuleContent<ModuleInfo>) -> MetadataPartProvider
         ): AnalysisResult {
             val moduleInfo = SourceModuleInfo(moduleName, capabilities, dependOnBuiltIns)
@@ -141,8 +142,14 @@ class CommonResolverForModuleFactory(private val shouldCheckExpectActual: Boolea
                         project: Project
                     ) = TargetPlatformVersion.NoVersion
                 },
-                resolverForModuleFactoryByPlatform = { CommonResolverForModuleFactory(shouldCheckExpectActual) },
-                platformParameters = { _ -> CommonAnalysisParameters(metadataPartProviderFactory) }
+                resolverForModuleFactoryByPlatform = {
+                    CommonResolverForModuleFactory(
+                        CommonAnalysisParameters(metadataPartProviderFactory),
+                        CompilerEnvironment,
+                        CommonPlatforms.defaultCommonPlatform,
+                        shouldCheckExpectActual = false
+                    )
+                }
             )
 
             val moduleDescriptor = resolver.descriptorForModule(moduleInfo)

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

@@ -29,7 +29,9 @@ import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.platform.jvm.isJvm
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
@@ -41,13 +43,15 @@ class JvmPlatformParameters(
 ) : PlatformAnalysisParameters
 
 
-object JvmResolverForModuleFactory : ResolverForModuleFactory() {
+class JvmResolverForModuleFactory(
+    private val platformParameters: JvmPlatformParameters,
+    private val targetEnvironment: TargetEnvironment,
+    private val platform: TargetPlatform
+) : ResolverForModuleFactory() {
     override fun <M : ModuleInfo> createResolverForModule(
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
         moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings
     ): ResolverForModule {

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

@@ -93,9 +93,7 @@ class ResolverForProjectImpl<M : ModuleInfo>(
     private val modulesContent: (M) -> ModuleContent<M>,
     private val moduleLanguageSettingsProvider: LanguageSettingsProvider,
     private val resolverForModuleFactoryByPlatform: (TargetPlatform?) -> ResolverForModuleFactory,
-    private val platformParameters: (TargetPlatform) -> PlatformAnalysisParameters,
     private val invalidateOnOOCB: Boolean,
-    private val targetEnvironment: TargetEnvironment = CompilerEnvironment,
     override val builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
     private val firstDependency: M? = null,
@@ -194,8 +192,6 @@ class ResolverForProjectImpl<M : ModuleInfo>(
                     descriptor as ModuleDescriptorImpl,
                     projectContext.withModule(descriptor),
                     moduleContent,
-                    platformParameters(module.platform),
-                    targetEnvironment,
                     this@ResolverForProjectImpl,
                     languageVersionSettings
                 )
@@ -308,8 +304,6 @@ abstract class ResolverForModuleFactory {
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
         moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings
     ): ResolverForModule

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
@@ -38,19 +39,20 @@ fun createResolveSessionForFiles(
         addBuiltIns: Boolean
 ): ResolveSession {
     val projectContext = ProjectContext(project, "lazy resolve test utils")
-    val testModule = TestModule(project, addBuiltIns)
+    val testModule =
+        TestModule(project, addBuiltIns)
+    val platformParameters = JvmPlatformParameters(
+        packagePartProviderFactory = { PackagePartProvider.Empty },
+        moduleByJavaClass = { testModule }
+    )
     val resolverForProject = ResolverForProjectImpl(
         "test",
         projectContext, listOf(testModule),
         { ModuleContent(it, syntheticFiles, GlobalSearchScope.allScope(project)) },
         invalidateOnOOCB = false,
         moduleLanguageSettingsProvider = LanguageSettingsProvider.Default,
-        resolverForModuleFactoryByPlatform = { JvmResolverForModuleFactory },
-        platformParameters = { _ ->
-            JvmPlatformParameters(
-                packagePartProviderFactory = { PackagePartProvider.Empty },
-                moduleByJavaClass = { testModule }
-            )
+        resolverForModuleFactoryByPlatform = {
+            JvmResolverForModuleFactory(platformParameters, CompilerEnvironment, JvmPlatforms.defaultJvmPlatform)
         }
     )
     return resolverForProject.resolverForModule(testModule).componentProvider.get<ResolveSession>()
@@ -61,10 +63,11 @@ private class TestModule(val project: Project, val dependsOnBuiltIns: Boolean) :
 
     override fun dependencies() = listOf(this)
     override fun dependencyOnBuiltIns() =
-            if (dependsOnBuiltIns)
-                ModuleInfo.DependencyOnBuiltIns.LAST
-            else
-                ModuleInfo.DependencyOnBuiltIns.NONE
+        if (dependsOnBuiltIns)
+            ModuleInfo.DependencyOnBuiltIns.LAST
+        else
+            ModuleInfo.DependencyOnBuiltIns.NONE
+
     override val platform: TargetPlatform
         get() = JvmPlatforms.unspecifiedJvmPlatform
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
@@ -79,21 +80,21 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
         val modules = setupModules(environment, moduleDirs)
         val projectContext = ProjectContext(environment.project, "MultiModuleJavaAnalysisTest")
         val builtIns = JvmBuiltIns(projectContext.storageManager, JvmBuiltIns.Kind.FROM_CLASS_LOADER)
+        val platformParameters = JvmPlatformParameters(
+            packagePartProviderFactory = { PackagePartProvider.Empty },
+            moduleByJavaClass = { javaClass ->
+                val moduleName = javaClass.name.asString().toLowerCase().first().toString()
+                modules.first { it._name == moduleName }
+            }
+        )
         val resolverForProject = ResolverForProjectImpl(
             "test",
             projectContext, modules,
             invalidateOnOOCB = false,
             modulesContent = { module -> ModuleContent(module, module.kotlinFiles, module.javaFilesScope) },
             moduleLanguageSettingsProvider = LanguageSettingsProvider.Default,
-            resolverForModuleFactoryByPlatform = { JvmResolverForModuleFactory },
-            platformParameters = { _ ->
-                JvmPlatformParameters(
-                    packagePartProviderFactory = { PackagePartProvider.Empty },
-                    moduleByJavaClass = { javaClass ->
-                        val moduleName = javaClass.name.asString().toLowerCase().first().toString()
-                        modules.first { it._name == moduleName }
-                    }
-                )
+            resolverForModuleFactoryByPlatform = {
+                JvmResolverForModuleFactory(platformParameters, CompilerEnvironment, JvmPlatforms.defaultJvmPlatform)
             },
             builtIns = builtIns
         )

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

@@ -7,7 +7,9 @@ package org.jetbrains.kotlin.caches.resolve
 
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
 import org.jetbrains.kotlin.analyzer.ResolverForModuleFactory
+import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
 import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
@@ -15,6 +17,8 @@ import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
 import org.jetbrains.kotlin.idea.framework.CommonLibraryKind
 import org.jetbrains.kotlin.platform.impl.CommonIdePlatformKind
+import org.jetbrains.kotlin.resolve.TargetEnvironment
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragment
 
 class CommonPlatformKindResolution : IdePlatformKindResolution {
@@ -27,10 +31,20 @@ class CommonPlatformKindResolution : IdePlatformKindResolution {
 
     override val kind get() = CommonIdePlatformKind
 
-    override val resolverForModuleFactory: ResolverForModuleFactory
-        get() = CommonResolverForModuleFactory(shouldCheckExpectActual = true)
-
     override fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext): KotlinBuiltIns {
         return DefaultBuiltIns.Instance
     }
+
+    override fun createResolverForModuleFactory(
+        settings: PlatformAnalysisParameters,
+        environment: TargetEnvironment,
+        platform: TargetPlatform
+    ): ResolverForModuleFactory {
+        return CommonResolverForModuleFactory(
+            settings as CommonAnalysisParameters,
+            environment,
+            platform,
+            shouldCheckExpectActual = true
+        )
+    }
 }

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

@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
 import org.jetbrains.kotlin.analyzer.ResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.context.ProjectContext
@@ -27,14 +28,20 @@ import org.jetbrains.kotlin.extensions.ApplicationExtensionDescriptor
 import org.jetbrains.kotlin.idea.caches.project.LibraryInfo
 import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
 import org.jetbrains.kotlin.platform.IdePlatformKind
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.resolve.TargetEnvironment
 
 interface IdePlatformKindResolution {
     val kind: IdePlatformKind<*>
 
-    val resolverForModuleFactory: ResolverForModuleFactory
-
     fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext): KotlinBuiltIns
 
+    fun createResolverForModuleFactory(
+        settings: PlatformAnalysisParameters,
+        environment: TargetEnvironment,
+        platform: TargetPlatform
+    ): ResolverForModuleFactory
+
     fun isLibraryFileForPlatform(virtualFile: VirtualFile): Boolean
 
     val libraryKind: PersistentLibraryKind<*>?

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.caches.resolve
 
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
 import org.jetbrains.kotlin.analyzer.ResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.context.ProjectContext
@@ -15,6 +16,8 @@ import org.jetbrains.kotlin.idea.framework.JSLibraryKind
 import org.jetbrains.kotlin.js.resolve.JsResolverForModuleFactory
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
 import org.jetbrains.kotlin.platform.impl.JsIdePlatformKind
+import org.jetbrains.kotlin.resolve.TargetEnvironment
+import org.jetbrains.kotlin.platform.TargetPlatform
 
 class JsPlatformKindResolution : IdePlatformKindResolution {
     override fun isLibraryFileForPlatform(virtualFile: VirtualFile): Boolean {
@@ -26,10 +29,13 @@ class JsPlatformKindResolution : IdePlatformKindResolution {
 
     override val kind get() = JsIdePlatformKind
 
-    override val resolverForModuleFactory: ResolverForModuleFactory
-        get() = JsResolverForModuleFactory
-
     override fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext): KotlinBuiltIns {
         return JsPlatformAnalyzerServices.builtIns
     }
+
+    override fun createResolverForModuleFactory(
+        settings: PlatformAnalysisParameters,
+        environment: TargetEnvironment,
+        platform: TargetPlatform
+    ): ResolverForModuleFactory = JsResolverForModuleFactory(environment)
 }

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

@@ -7,13 +7,17 @@ package org.jetbrains.kotlin.caches.resolve
 
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
 import org.jetbrains.kotlin.analyzer.ResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
+import org.jetbrains.kotlin.resolve.TargetEnvironment
+import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
 
 class JvmPlatformKindResolution : IdePlatformKindResolution {
@@ -21,14 +25,19 @@ class JvmPlatformKindResolution : IdePlatformKindResolution {
         return false // TODO: No library kind for JVM
     }
 
+    override fun createResolverForModuleFactory(
+        settings: PlatformAnalysisParameters,
+        environment: TargetEnvironment,
+        platform: TargetPlatform
+    ): ResolverForModuleFactory {
+        return JvmResolverForModuleFactory(settings as JvmPlatformParameters, environment, platform)
+    }
+
     override val libraryKind: PersistentLibraryKind<*>?
         get() = null
 
     override val kind get() = JvmIdePlatformKind
 
-    override val resolverForModuleFactory: ResolverForModuleFactory
-        get() = JvmResolverForModuleFactory
-
     override fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext): KotlinBuiltIns =
         if (settings.sdk != null)
             JvmBuiltIns(projectContext.storageManager, JvmBuiltIns.Kind.FROM_CLASS_LOADER)

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

@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompositeBindingContext
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
+import org.jetbrains.kotlin.platform.DefaultIdeTargetPlatformKindProvider
 
 internal class ProjectResolutionFacade(
     private val debugString: String,
@@ -141,17 +142,15 @@ internal class ProjectResolutionFacade(
             modulesContentFactory,
             moduleLanguageSettingsProvider = IDELanguageSettingsProvider,
             resolverForModuleFactoryByPlatform = { modulePlatform ->
-                val platform = modulePlatform ?: settings.platform
-                platform.idePlatformKind.resolution.resolverForModuleFactory
-            },
-            platformParameters = { platform ->
-                when {
+                val platform = modulePlatform ?: DefaultIdeTargetPlatformKindProvider.defaultPlatform
+                val parameters = when {
                     platform.isJvm() -> jvmPlatformParameters
                     platform.isCommon() -> commonPlatformParameters
                     else -> PlatformAnalysisParameters.Empty
                 }
+
+                platform.idePlatformKind.resolution.createResolverForModuleFactory(parameters, IdeaEnvironment, platform)
             },
-            targetEnvironment = IdeaEnvironment,
             builtIns = builtIns,
             delegateResolver = delegateResolverForProject,
             firstDependency = settings.sdk?.let { SdkInfo(project, it) },
@@ -215,7 +214,9 @@ internal class ProjectResolutionFacade(
 
     private companion object {
         private fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext): KotlinBuiltIns {
-            return settings.platform.idePlatformKind.resolution.createBuiltIns(settings, projectContext)
+//            return settings.platform.idePlatformKind.resolution.createBuiltIns(settings, projectContext)
+//             TODO: what we do about built-ins?
+            return JvmPlatforms.defaultJvmPlatform.idePlatformKind.resolution.createBuiltIns(settings, projectContext)
         }
     }
 }

idea/idea-jvm/src/org/jetbrains/kotlin/idea/platform/CommonIdePlatformKindTooling.kt

@@ -34,8 +34,6 @@ object CommonIdePlatformKindTooling : IdePlatformKindTooling() {
 
     override fun compilerArgumentsForProject(project: Project): CommonCompilerArguments? = null
 
-    override val resolverForModuleFactory = CommonResolverForModuleFactory(true)
-
     override val mavenLibraryIds = listOf(MAVEN_COMMON_STDLIB_ID)
     override val gradlePluginId = "kotlin-platform-common"
     override val gradlePlatformIds: List<KotlinPlatform> get() = listOf(KotlinPlatform.COMMON)

idea/idea-jvm/src/org/jetbrains/kotlin/idea/platform/JsIdePlatformKindTooling.kt

@@ -49,8 +49,6 @@ class JsIdePlatformKindTooling : IdePlatformKindTooling() {
 
     override fun compilerArgumentsForProject(project: Project) = Kotlin2JsCompilerArgumentsHolder.getInstance(project).settings
 
-    override val resolverForModuleFactory = JsResolverForModuleFactory
-
     override val mavenLibraryIds = listOf(PathUtil.JS_LIB_NAME, MAVEN_OLD_JS_STDLIB_ID)
     override val gradlePluginId = "kotlin-platform-js"
     override val gradlePlatformIds: List<KotlinPlatform> get() = listOf(KotlinPlatform.JS)

idea/idea-jvm/src/org/jetbrains/kotlin/idea/platform/JvmIdePlatformKindTooling.kt

@@ -33,8 +33,6 @@ class JvmIdePlatformKindTooling : IdePlatformKindTooling() {
 
     override fun compilerArgumentsForProject(project: Project) = Kotlin2JvmCompilerArgumentsHolder.getInstance(project).settings
 
-    override val resolverForModuleFactory = JvmResolverForModuleFactory
-
     override val mavenLibraryIds = listOf(
         PathUtil.KOTLIN_JAVA_STDLIB_NAME,
         PathUtil.KOTLIN_JAVA_RUNTIME_JRE7_NAME,

idea/idea-native/src/org/jetbrains/kotlin/ide/konan/NativeIdePlatformKindTooling.kt

@@ -29,8 +29,6 @@ class NativeIdePlatformKindTooling : IdePlatformKindTooling() {
 
     override fun compilerArgumentsForProject(project: Project): CommonCompilerArguments? = null
 
-    override val resolverForModuleFactory get() = NativeResolverForModuleFactory
-
     override val mavenLibraryIds: List<String> get() = emptyList()
     override val gradlePluginId: String get() = ""
     override val gradlePlatformIds: List<KotlinPlatform> get() = listOf(KotlinPlatform.NATIVE)

idea/idea-native/src/org/jetbrains/kotlin/ide/konan/NativePlatformKindResolution.kt

@@ -64,13 +64,19 @@ class NativePlatformKindResolution : IdePlatformKindResolution {
         }
     }
 
+    override fun createResolverForModuleFactory(
+        settings: PlatformAnalysisParameters,
+        environment: TargetEnvironment,
+        platform: TargetPlatform
+    ): ResolverForModuleFactory {
+        return NativeResolverForModuleFactory(settings, environment, platform)
+    }
+
     override val libraryKind: PersistentLibraryKind<*>?
         get() = NativeLibraryKind
 
     override val kind get() = NativeIdePlatformKind
 
-    override val resolverForModuleFactory get() = NativeResolverForModuleFactory
-
     override fun createBuiltIns(settings: PlatformAnalysisSettings, projectContext: ProjectContext) =
         createKotlinNativeBuiltIns(settings, projectContext)
 }

idea/idea-native/src/org/jetbrains/kotlin/ide/konan/analyzer/NativeResolverForModuleFactory.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve
 import org.jetbrains.kotlin.ide.konan.NativeLibraryInfo
 import org.jetbrains.kotlin.ide.konan.createPackageFragmentProvider
+import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.konan.KonanPlatforms
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.TargetEnvironment
@@ -21,13 +22,15 @@ import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerService
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService.Companion.createDeclarationProviderFactory
 
-object NativeResolverForModuleFactory : ResolverForModuleFactory() {
+class NativeResolverForModuleFactory(
+    private val platformAnalysisParameters: PlatformAnalysisParameters,
+    private val targetEnvironment: TargetEnvironment,
+    private val targetPlatform: TargetPlatform
+) : ResolverForModuleFactory() {
     override fun <M : ModuleInfo> createResolverForModule(
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
         moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings
     ): ResolverForModule {

idea/src/org/jetbrains/kotlin/idea/platform/IdePlatformKindTooling.kt

@@ -24,8 +24,6 @@ abstract class IdePlatformKindTooling {
 
     abstract fun compilerArgumentsForProject(project: Project): CommonCompilerArguments?
 
-    abstract val resolverForModuleFactory: ResolverForModuleFactory
-
     abstract val mavenLibraryIds: List<String>
     abstract val gradlePluginId: String
 

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsResolverForModuleFactory.kt

@@ -21,13 +21,13 @@ import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
 import org.jetbrains.kotlin.serialization.js.createKotlinJavascriptPackageFragmentProvider
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 
-object JsResolverForModuleFactory : ResolverForModuleFactory() {
+class JsResolverForModuleFactory(
+    private val targetEnvironment: TargetEnvironment
+) : ResolverForModuleFactory() {
     override fun <M : ModuleInfo> createResolverForModule(
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
         moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings
     ): ResolverForModule {