Refactoring: collect callbacks for collecting module info in one place

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

@@ -85,17 +85,17 @@ class ResolverForProjectImpl<M : ModuleInfo>(
     private val debugName: String,
     private val projectContext: ProjectContext,
     modules: Collection<M>,
-    private val resolverForModuleFactoryByPlatform: (TargetPlatform?) -> ResolverForModuleFactory,
     private val modulesContent: (M) -> ModuleContent<M>,
+    private val modulePlatforms: (M) -> MultiTargetPlatform?,
+    private val moduleLanguageSettingsProvider: LanguageSettingsProvider,
+    private val resolverForModuleFactoryByPlatform: (TargetPlatform?) -> ResolverForModuleFactory,
     private val platformParameters: PlatformAnalysisParameters,
     private val targetEnvironment: TargetEnvironment = CompilerEnvironment,
     override val builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
     private val packagePartProviderFactory: (ModuleContent<M>) -> PackagePartProvider = { _ -> PackagePartProvider.Empty },
     private val firstDependency: M? = null,
-    private val modulePlatforms: (M) -> MultiTargetPlatform?,
     private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory,
-    private val languageSettingsProvider: LanguageSettingsProvider = LanguageSettingsProvider.Default,
     private val invalidateOnOOCB: Boolean = true
 ) : ResolverForProject<M>() {
 
@@ -174,8 +174,8 @@ class ResolverForProjectImpl<M : ModuleInfo>(
                 val packagePartProvider = packagePartProviderFactory(moduleContent)
                 val resolverForModuleFactory = resolverForModuleFactoryByPlatform(module.platform)
 
-                val languageVersionSettings = languageSettingsProvider.getLanguageVersionSettings(module, projectContext.project)
+                val languageVersionSettings = moduleLanguageSettingsProvider.getLanguageVersionSettings(module, projectContext.project)
-                val targetPlatformVersion = languageSettingsProvider.getTargetPlatform(module)
+                val targetPlatformVersion = moduleLanguageSettingsProvider.getTargetPlatform(module)
 
                 resolverForModuleFactory.createResolverForModule(
                     descriptor as ModuleDescriptorImpl,

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

@@ -80,15 +80,15 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
             "sources for metadata serializer",
             ProjectContext(project),
             listOf(moduleInfo),
-            resolverForModuleFactoryByPlatform = { CommonAnalyzerFacade },
             modulesContent = { ModuleContent(it, files, GlobalSearchScope.allScope(project)) },
-            platformParameters = object : PlatformAnalysisParameters {},
+            modulePlatforms = { MultiTargetPlatform.Common },
-            languageSettingsProvider = object : LanguageSettingsProvider {
+            moduleLanguageSettingsProvider = object : LanguageSettingsProvider {
                 override fun getLanguageVersionSettings(moduleInfo: ModuleInfo, project: Project) = multiplatformLanguageSettings
                 override fun getTargetPlatform(moduleInfo: ModuleInfo) = TargetPlatformVersion.NoVersion
             },
-            packagePartProviderFactory = packagePartProviderFactory,
+            resolverForModuleFactoryByPlatform = { CommonAnalyzerFacade },
-            modulePlatforms = { MultiTargetPlatform.Common }
+            platformParameters = object : PlatformAnalysisParameters {},
+            packagePartProviderFactory = packagePartProviderFactory
         )
 
         val moduleDescriptor = resolver.descriptorForModule(moduleInfo)

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

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve.lazy
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analyzer.LanguageSettingsProvider
 import org.jetbrains.kotlin.analyzer.ModuleContent
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.analyzer.ResolverForProjectImpl
@@ -37,12 +38,13 @@ fun createResolveSessionForFiles(
     val projectContext = ProjectContext(project)
     val testModule = TestModule(addBuiltIns)
     val resolverForProject = ResolverForProjectImpl(
-            "test",
+        "test",
-            projectContext, listOf(testModule),
+        projectContext, listOf(testModule),
-            { JvmAnalyzerFacade },
+        { ModuleContent(it, syntheticFiles, GlobalSearchScope.allScope(project)) },
-            { ModuleContent(it, syntheticFiles, GlobalSearchScope.allScope(project)) },
+        modulePlatforms = { JvmPlatform.multiTargetPlatform },
-            JvmPlatformParameters { testModule },
+        moduleLanguageSettingsProvider = LanguageSettingsProvider.Default,
-            modulePlatforms = { JvmPlatform.multiTargetPlatform }
+        resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
+        platformParameters = JvmPlatformParameters { testModule }
     )
     return resolverForProject.resolverForModule(testModule).componentProvider.get<ResolveSession>()
 }

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

@@ -19,10 +19,7 @@ package org.jetbrains.kotlin.jvm.compiler
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.DelegatingGlobalSearchScope
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analyzer.ModuleContent
+import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.analyzer.ResolverForProject
-import org.jetbrains.kotlin.analyzer.ResolverForProjectImpl
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
@@ -36,7 +33,6 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.constants.EnumValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
@@ -69,17 +65,18 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
         val projectContext = ProjectContext(environment.project)
         val builtIns = JvmBuiltIns(projectContext.storageManager)
         val resolverForProject = ResolverForProjectImpl(
-                "test",
+            "test",
-                projectContext, modules,
+            projectContext, modules,
-                { JvmAnalyzerFacade },
+            modulesContent = { module -> ModuleContent(module, module.kotlinFiles, module.javaFilesScope) },
-                modulesContent = { module -> ModuleContent(module, module.kotlinFiles, module.javaFilesScope) },
+            modulePlatforms = { JvmPlatform.multiTargetPlatform },
-                platformParameters = JvmPlatformParameters {
+            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default,
-                    javaClass ->
+            resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
-                    val moduleName = javaClass.name.asString().toLowerCase().first().toString()
+            platformParameters = JvmPlatformParameters {
-                    modules.first { it._name == moduleName }
+                javaClass ->
-                },
+                val moduleName = javaClass.name.asString().toLowerCase().first().toString()
-                builtIns = builtIns,
+                modules.first { it._name == moduleName }
-                modulePlatforms = { JvmPlatform.multiTargetPlatform }
+            },
+            builtIns = builtIns
         )
 
         builtIns.initialize(

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

@@ -123,20 +123,20 @@ internal class ProjectResolutionFacade(
             resolverDebugName,
             globalContext.withProject(project),
             modulesToCreateResolversFor,
-            { modulePlatform ->
+            modulesContentFactory,
+            modulePlatforms = { module -> module.platform?.multiTargetPlatform },
+            moduleLanguageSettingsProvider = IDELanguageSettingsProvider,
+            resolverForModuleFactoryByPlatform = { modulePlatform ->
                 val platform = modulePlatform ?: settings.platform
                 IdePlatformSupport.facades[platform] ?: throw UnsupportedOperationException("Unsupported platform $platform")
             },
-            modulesContentFactory,
+            platformParameters = jvmPlatformParameters,
-            jvmPlatformParameters,
+            targetEnvironment = IdeaEnvironment,
-            IdeaEnvironment,
+            builtIns = builtIns,
-            builtIns,
+            delegateResolver = delegateResolverForProject,
-            delegateResolverForProject,
             packagePartProviderFactory = { moduleContent -> IDEPackagePartProvider(moduleContent.moduleContentScope) },
             firstDependency = settings.sdk?.let { SdkInfo(project, it) },
-            modulePlatforms = { module -> module.platform?.multiTargetPlatform },
             packageOracleFactory = ServiceManager.getService(project, IdePackageOracleFactory::class.java),
-            languageSettingsProvider = IDELanguageSettingsProvider,
             invalidateOnOOCB = invalidateOnOOCB
         )