Move entire logic for ModuleDescriptor setup into ResolverForProjectImpl

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

@@ -43,7 +43,6 @@ import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.storage.NotNullLazyValue
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.utils.keysToMap
 import java.util.*
 import kotlin.coroutines.experimental.buildSequence
 
@@ -75,16 +74,33 @@ class EmptyResolverForProject<M : ModuleInfo> : ResolverForProject<M>() {
 }
 
 class ResolverForProjectImpl<M : ModuleInfo>(
-        val projectContext: ProjectContext,
-        analyzerFacade: (M) -> AnalyzerFacade,
-        modulesContent: (M) -> ModuleContent,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
-        packagePartProviderFactory: (M, ModuleContent) -> PackagePartProvider,
         private val debugName: String,
-        private val descriptorByModule: Map<M, ModuleDescriptorImpl>,
+        private val projectContext: ProjectContext,
-        private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject()
+        modules: Collection<M>,
+        analyzerFacade: (M) -> AnalyzerFacade,
+        private val modulesContent: (M) -> ModuleContent,
+        platformParameters: PlatformAnalysisParameters,
+        targetEnvironment: TargetEnvironment = CompilerEnvironment,
+        builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance,
+        val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
+        packagePartProviderFactory: (M, ModuleContent) -> PackagePartProvider = { _, _ -> PackagePartProvider.Empty },
+        private val firstDependency: M? = null,
+        private val modulePlatforms: (M) -> MultiTargetPlatform?,
+        private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory
 ) : ResolverForProject<M>() {
+    val descriptorByModule = mutableMapOf<M, ModuleDescriptorImpl>()
+
+    init {
+        for (module in modules) {
+            descriptorByModule[module] = ModuleDescriptorImpl(module.name,
+                 projectContext.storageManager, builtIns, modulePlatforms(module), module.capabilities)
+        }
+
+        for ((module, moduleDescriptor) in descriptorByModule) {
+            setupModuleDescriptor(module, moduleDescriptor)
+        }
+    }
+
     override fun tryGetResolverForModule(moduleInfo: M): ResolverForModule? {
         if (!isCorrectModuleInfo(moduleInfo)) {
             return null
@@ -92,6 +108,19 @@ class ResolverForProjectImpl<M : ModuleInfo>(
         return resolverForModuleDescriptor(doGetDescriptorForModule(moduleInfo))
     }
 
+    private fun setupModuleDescriptor(module: M, moduleDescriptor: ModuleDescriptorImpl) {
+        moduleDescriptor.setDependencies(LazyModuleDependencies(
+                projectContext.storageManager,
+                module,
+                modulePlatforms,
+                firstDependency,
+                this))
+
+        val content = modulesContent(module)
+        moduleDescriptor.initialize(
+                DelegatingPackageFragmentProvider(this, moduleDescriptor, content,
+                                                  packageOracleFactory.createOracle(module)))
+    }
     internal val resolverByModuleDescriptor: Map<ModuleDescriptor, NotNullLazyValue<ResolverForModule>> = descriptorByModule.map { (module, descriptor) ->
         descriptor to projectContext.storageManager.createLazyValue {
             ResolverForModuleComputationTracker.getInstance(projectContext.project)?.onResolverComputed(module)
@@ -173,56 +202,6 @@ interface ModuleInfo {
 }
 
 abstract class AnalyzerFacade {
-    companion object {
-        fun <M : ModuleInfo> setupResolverForProject(
-                debugName: String,
-                projectContext: ProjectContext,
-                modules: Collection<M>,
-                analyzerFacade: (M) -> AnalyzerFacade,
-                modulesContent: (M) -> ModuleContent,
-                platformParameters: PlatformAnalysisParameters,
-                languageSettingsProvider: LanguageSettingsProvider = LanguageSettingsProvider.Default,
-                targetEnvironment: TargetEnvironment = CompilerEnvironment,
-                builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance,
-                delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
-                packagePartProviderFactory: (M, ModuleContent) -> PackagePartProvider = { _, _ -> PackagePartProvider.Empty },
-                firstDependency: M? = null,
-                modulePlatforms: (M) -> MultiTargetPlatform?,
-                packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory
-        ): ResolverForProject<M> {
-            val storageManager = projectContext.storageManager
-
-            val resolverForProject = ResolverForProjectImpl(
-                    projectContext,
-                    analyzerFacade,
-                    modulesContent,
-                    platformParameters,
-                    targetEnvironment,
-                    packagePartProviderFactory,
-                    debugName,
-                    modules.keysToMap { module ->
-                        ModuleDescriptorImpl(module.name, storageManager, builtIns, modulePlatforms(module), module.capabilities)
-                    }, delegateResolver)
-
-            for (module in modules) {
-                val moduleDescriptor = resolverForProject.descriptorForModule(module)
-                moduleDescriptor.setDependencies(LazyModuleDependencies(
-                        storageManager,
-                        module,
-                        modulePlatforms,
-                        firstDependency,
-                        resolverForProject))
-
-                val content = modulesContent(module)
-                moduleDescriptor.initialize(
-                        DelegatingPackageFragmentProvider(resolverForProject, moduleDescriptor, content,
-                                                          packageOracleFactory.createOracle(module)))
-            }
-
-            return resolverForProject
-        }
-    }
-
     abstract fun <M : ModuleInfo> createResolverForModule(
             moduleInfo: M,
             moduleDescriptor: ModuleDescriptorImpl,

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

@@ -73,7 +73,7 @@ object DefaultAnalyzerFacade : AnalyzerFacade() {
         }
 
         @Suppress("NAME_SHADOWING")
-        val resolver = setupResolverForProject(
+        val resolver = ResolverForProjectImpl   (
                 "sources for metadata serializer",
                 ProjectContext(project), listOf(moduleInfo), { DefaultAnalyzerFacade },
                 { ModuleContent(files, GlobalSearchScope.allScope(project)) },

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

@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.resolve.lazy
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analyzer.AnalyzerFacade
 import org.jetbrains.kotlin.analyzer.ModuleContent
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.ResolverForProjectImpl
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.name.Name
@@ -36,7 +36,7 @@ fun createResolveSessionForFiles(
 ): ResolveSession {
     val projectContext = ProjectContext(project)
     val testModule = TestModule(addBuiltIns)
-    val resolverForProject = AnalyzerFacade.setupResolverForProject(
+    val resolverForProject = ResolverForProjectImpl(
             "test",
             projectContext, listOf(testModule), { JvmAnalyzerFacade },
             { ModuleContent(syntheticFiles, GlobalSearchScope.allScope(project)) },

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

@@ -19,10 +19,10 @@ 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.AnalyzerFacade
 import org.jetbrains.kotlin.analyzer.ModuleContent
 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
@@ -67,7 +67,7 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
         val modules = setupModules(environment, moduleDirs)
         val projectContext = ProjectContext(environment.project)
         val builtIns = JvmBuiltIns(projectContext.storageManager)
-        val resolverForProject = AnalyzerFacade.setupResolverForProject(
+        val resolverForProject = ResolverForProjectImpl(
                 "test",
                 projectContext, modules, { JvmAnalyzerFacade },
                 { module -> ModuleContent(module.kotlinFiles, module.javaFilesScope) },

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

@@ -24,9 +24,9 @@ import com.intellij.openapi.projectRoots.Sdk
 import com.intellij.openapi.roots.JdkOrderEntry
 import com.intellij.openapi.roots.LibraryOrderEntry
 import com.intellij.openapi.roots.ModuleRootManager
-import org.jetbrains.kotlin.analyzer.AnalyzerFacade
 import org.jetbrains.kotlin.analyzer.ModuleContent
 import org.jetbrains.kotlin.analyzer.ResolverForProject
+import org.jetbrains.kotlin.analyzer.ResolverForProjectImpl
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.context.GlobalContextImpl
@@ -73,7 +73,7 @@ fun createModuleResolverProvider(
         psiClass.getNullableModuleInfo()
     }
 
-    val resolverForProject = AnalyzerFacade.setupResolverForProject(
+    val resolverForProject = ResolverForProjectImpl(
             debugName, globalContext.withProject(project), modulesToCreateResolversFor,
             { module -> AnalyzerFacadeProvider.getAnalyzerFacade(module.platform ?: analysisSettings.platform) },
             modulesContent, jvmPlatformParameters,