Refactoring: streamline module resolver setup code

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

@@ -28,6 +28,7 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.SLRUCache
+import org.jetbrains.kotlin.analyzer.LanguageSettingsProvider
 import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
@@ -375,25 +376,3 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
     }
 }
 
-internal fun globalResolveSessionProvider(
-        debugName: String,
-        project: Project,
-        globalContext: GlobalContextImpl,
-        settings: PlatformAnalysisSettings,
-        dependencies: Collection<Any>,
-        moduleFilter: (IdeaModuleInfo) -> Boolean,
-        reuseDataFrom: ProjectResolutionFacade? = null,
-        syntheticFiles: Collection<KtFile> = listOf(),
-        allModules: Collection<IdeaModuleInfo>? = null // null means create resolvers for modules from idea model
-): ModuleResolverProvider {
-    val delegateResolverProvider = reuseDataFrom?.moduleResolverProvider
-    val delegateResolverForProject = delegateResolverProvider?.resolverForProject ?: EmptyResolverForProject()
-
-    return createModuleResolverProvider(
-            debugName, project, globalContext, settings,
-            syntheticFiles, delegateResolverForProject, moduleFilter,
-            allModules,
-            delegateResolverProvider?.builtIns,
-            dependencies
-    )
-}

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

@@ -64,37 +64,33 @@ fun createModuleResolverProvider(
 
     val modulesToCreateResolversFor = allModuleInfos.filter(moduleFilter)
 
-    fun createResolverForProject(): ResolverForProject<IdeaModuleInfo> {
+    val modulesContent = { module: IdeaModuleInfo ->
-        val modulesContent = { module: IdeaModuleInfo ->
+        ModuleContent(syntheticFilesByModule[module] ?: listOf(), module.contentScope())
-            ModuleContent(syntheticFilesByModule[module] ?: listOf(), module.contentScope())
-        }
-
-        val jvmPlatformParameters = JvmPlatformParameters { javaClass: JavaClass ->
-            val psiClass = (javaClass as JavaClassImpl).psi
-            psiClass.getNullableModuleInfo()
-        }
-
-        return AnalyzerFacade.setupResolverForProject(
-                debugName, globalContext.withProject(project), modulesToCreateResolversFor,
-                { module -> AnalyzerFacadeProvider.getAnalyzerFacade(module.platform ?: analysisSettings.platform) },
-                modulesContent, jvmPlatformParameters,
-                IDELanguageSettingsProvider,
-                IdeaEnvironment, builtIns,
-                delegateResolver, { _, c -> IDEPackagePartProvider(c.moduleContentScope) },
-                analysisSettings.sdk?.let { SdkInfo(project, it) },
-                modulePlatforms = { module -> module.platform?.multiTargetPlatform },
-                packageOracleFactory = project.service<IdePackageOracleFactory>()
-        )
     }
 
-    val resolverForProject = createResolverForProject()
+    val jvmPlatformParameters = JvmPlatformParameters { javaClass: JavaClass ->
+        val psiClass = (javaClass as JavaClassImpl).psi
+        psiClass.getNullableModuleInfo()
+    }
+
+    val resolverForProject = AnalyzerFacade.setupResolverForProject(
+            debugName, globalContext.withProject(project), modulesToCreateResolversFor,
+            { module -> AnalyzerFacadeProvider.getAnalyzerFacade(module.platform ?: analysisSettings.platform) },
+            modulesContent, jvmPlatformParameters,
+                IDELanguageSettingsProvider,
+                IdeaEnvironment, builtIns,
+            delegateResolver, { _, c -> IDEPackagePartProvider(c.moduleContentScope) },
+            analysisSettings.sdk?.let { SdkInfo(project, it) },
+            modulePlatforms = { module -> module.platform?.multiTargetPlatform },
+            packageOracleFactory = project.service<IdePackageOracleFactory>()
+    )
 
     if (providedBuiltIns == null && builtIns is JvmBuiltIns) {
         val sdkModuleDescriptor = analysisSettings.sdk!!.let { resolverForProject.descriptorForModule(SdkInfo(project, it)) }
         builtIns.initialize(sdkModuleDescriptor, analysisSettings.isAdditionalBuiltInFeaturesSupported)
     }
 
-    return ModuleResolverProviderImpl(
+    return ModuleResolverProvider(
             resolverForProject,
             builtIns,
             dependencies + listOf(globalContext.exceptionTracker)
@@ -137,14 +133,8 @@ fun getAllProjectSdks(): Collection<Sdk> {
 }
 
 
-interface ModuleResolverProvider {
+class ModuleResolverProvider(
-    val resolverForProject: ResolverForProject<IdeaModuleInfo>
+        val resolverForProject: ResolverForProject<IdeaModuleInfo>,
-    val builtIns: KotlinBuiltIns
+        val builtIns: KotlinBuiltIns,
-    val cacheDependencies: Collection<Any>
+        val cacheDependencies: Collection<Any>
-}
+)
-
-class ModuleResolverProviderImpl(
-        override val resolverForProject: ResolverForProject<IdeaModuleInfo>,
-        override val builtIns: KotlinBuiltIns,
-        override val cacheDependencies: Collection<Any>
-) : ModuleResolverProvider

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

@@ -22,6 +22,7 @@ import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.SLRUCache
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
 import org.jetbrains.kotlin.context.GlobalContextImpl
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.psi.KtElement
@@ -49,16 +50,18 @@ internal class ProjectResolutionFacade(
     )
 
     private fun computeModuleResolverProvider(): ModuleResolverProvider {
-        return globalResolveSessionProvider(
+        val delegateResolverProvider = reuseDataFrom?.moduleResolverProvider
+        val delegateResolverForProject = delegateResolverProvider?.resolverForProject ?: EmptyResolverForProject()
+        return createModuleResolverProvider(
                 resolverDebugName,
                 project,
                 globalContext,
                 settings,
-                moduleFilter = moduleFilter,
+                syntheticFiles = syntheticFiles,
-                dependencies = dependencies,
+                delegateResolver = delegateResolverForProject, moduleFilter = moduleFilter,
-                reuseDataFrom = reuseDataFrom,
                 allModules = allModules,
-                syntheticFiles = syntheticFiles
+                providedBuiltIns = delegateResolverProvider?.builtIns,
+                dependencies = dependencies
         )
     }