Refactoring: store correspondent module info in module content

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt

@@ -64,7 +64,7 @@ open class MetadataSerializer(private val dependOnOldBuiltIns: Boolean) {
 
         val analyzer = AnalyzerWithCompilerReport(messageCollector, configuration.languageVersionSettings)
         analyzer.analyzeAndReport(files) {
-            CommonAnalyzerFacade.analyzeFiles(files, moduleName, dependOnOldBuiltIns, configuration.languageVersionSettings) { _, content ->
+            CommonAnalyzerFacade.analyzeFiles(files, moduleName, dependOnOldBuiltIns, configuration.languageVersionSettings) { content ->
                 environment.createPackagePartProvider(content.moduleContentScope)
             }
         }

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

@@ -43,17 +43,16 @@ class JvmPlatformParameters(
 
 object JvmAnalyzerFacade : ResolverForModuleFactory() {
     override fun <M : ModuleInfo> createResolverForModule(
-        moduleInfo: M,
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
-        moduleContent: ModuleContent,
+        moduleContent: ModuleContent<M>,
         platformParameters: PlatformAnalysisParameters,
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageSettingsProvider: LanguageSettingsProvider,
         packagePartProvider: PackagePartProvider
     ): ResolverForModule {
-        val (syntheticFiles, moduleContentScope) = moduleContent
+        val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
             project, moduleContext.storageManager, syntheticFiles,

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

@@ -86,12 +86,12 @@ class ResolverForProjectImpl<M : ModuleInfo>(
     private val projectContext: ProjectContext,
     modules: Collection<M>,
     private val resolverForModuleFactoryByPlatform: (TargetPlatform?) -> ResolverForModuleFactory,
-    private val modulesContent: (M) -> ModuleContent,
+    private val modulesContent: (M) -> ModuleContent<M>,
     private val platformParameters: PlatformAnalysisParameters,
     private val targetEnvironment: TargetEnvironment = CompilerEnvironment,
     override val builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
-    private val packagePartProviderFactory: (M, ModuleContent) -> PackagePartProvider = { _, _ -> PackagePartProvider.Empty },
+    private val packagePartProviderFactory: (ModuleContent<M>) -> PackagePartProvider = { _ -> PackagePartProvider.Empty },
     private val firstDependency: M? = null,
     private val modulePlatforms: (M) -> MultiTargetPlatform?,
     private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory,
@@ -170,11 +170,19 @@ class ResolverForProjectImpl<M : ModuleInfo>(
 
                 ResolverForModuleComputationTracker.getInstance(projectContext.project)?.onResolverComputed(module)
 
-                resolverForModuleFactoryByPlatform(module.platform).createResolverForModule(
+                val moduleContent = modulesContent(module)
-                    module, descriptor as ModuleDescriptorImpl, projectContext.withModule(descriptor), modulesContent(module),
+                val packagePartProvider = packagePartProviderFactory(moduleContent)
-                    platformParameters, targetEnvironment, this@ResolverForProjectImpl,
+                val resolverForModuleFactory = resolverForModuleFactoryByPlatform(module.platform)
+
+                resolverForModuleFactory.createResolverForModule(
+                    descriptor as ModuleDescriptorImpl,
+                    projectContext.withModule(descriptor),
+                    moduleContent,
+                    platformParameters,
+                    targetEnvironment,
+                    this@ResolverForProjectImpl,
                     languageSettingsProvider,
-                    packagePartProviderFactory(module, modulesContent(module))
+                    packagePartProvider
                 )
             }
         }
@@ -241,7 +249,8 @@ class ResolverForProjectImpl<M : ModuleInfo>(
     }
 }
 
-data class ModuleContent(
+data class ModuleContent<out M: ModuleInfo>(
+    val moduleInfo: M,
     val syntheticFiles: Collection<KtFile>,
     val moduleContentScope: GlobalSearchScope
 )
@@ -283,10 +292,9 @@ interface TrackableModuleInfo : ModuleInfo {
 
 abstract class ResolverForModuleFactory {
     abstract fun <M : ModuleInfo> createResolverForModule(
-        moduleInfo: M,
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
-        moduleContent: ModuleContent,
+        moduleContent: ModuleContent<M>,
         platformParameters: PlatformAnalysisParameters,
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
@@ -339,7 +347,7 @@ class LazyModuleDependencies<M : ModuleInfo>(
 private class DelegatingPackageFragmentProvider<M : ModuleInfo>(
     private val resolverForProject: ResolverForProjectImpl<M>,
     private val module: ModuleDescriptor,
-    moduleContent: ModuleContent,
+    moduleContent: ModuleContent<M>,
     private val packageOracle: PackageOracle
 ) : PackageFragmentProvider {
     private val syntheticFilePackages = moduleContent.syntheticFiles.map { it.packageFqName }.toSet()

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

@@ -64,7 +64,7 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
     fun analyzeFiles(
         files: Collection<KtFile>, moduleName: Name, dependOnBuiltIns: Boolean, languageVersionSettings: LanguageVersionSettings,
         capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = mapOf(MultiTargetPlatform.CAPABILITY to MultiTargetPlatform.Common),
-        packagePartProviderFactory: (ModuleInfo, ModuleContent) -> PackagePartProvider
+        packagePartProviderFactory: (ModuleContent<ModuleInfo>) -> PackagePartProvider
     ): AnalysisResult {
         val moduleInfo = SourceModuleInfo(moduleName, capabilities, dependOnBuiltIns)
         val project = files.firstOrNull()?.project ?: throw AssertionError("No files to analyze")
@@ -81,7 +81,7 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
             ProjectContext(project),
             listOf(moduleInfo),
             resolverForModuleFactoryByPlatform = { CommonAnalyzerFacade },
-            modulesContent = { ModuleContent(files, GlobalSearchScope.allScope(project)) },
+            modulesContent = { ModuleContent(it, files, GlobalSearchScope.allScope(project)) },
             platformParameters = object : PlatformAnalysisParameters {},
             languageSettingsProvider = object : LanguageSettingsProvider {
                 override fun getLanguageVersionSettings(moduleInfo: ModuleInfo, project: Project) = multiplatformLanguageSettings
@@ -100,17 +100,16 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
     }
 
     override fun <M : ModuleInfo> createResolverForModule(
-        moduleInfo: M,
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
-        moduleContent: ModuleContent,
+        moduleContent: ModuleContent<M>,
         platformParameters: PlatformAnalysisParameters,
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageSettingsProvider: LanguageSettingsProvider,
         packagePartProvider: PackagePartProvider
     ): ResolverForModule {
-        val (syntheticFiles, moduleContentScope) = moduleContent
+        val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
             project, moduleContext.storageManager, syntheticFiles,

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

@@ -330,7 +330,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() {
                     MultiTargetPlatform.CAPABILITY to MultiTargetPlatform.Common,
                     MODULE_FILES to files
                 )
-            ) { _, _ ->
+            ) { _ ->
                 // TODO
                 PackagePartProvider.Empty
             }

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

@@ -40,7 +40,7 @@ fun createResolveSessionForFiles(
             "test",
             projectContext, listOf(testModule),
             { JvmAnalyzerFacade },
-            { ModuleContent(syntheticFiles, GlobalSearchScope.allScope(project)) },
+            { ModuleContent(it, syntheticFiles, GlobalSearchScope.allScope(project)) },
             JvmPlatformParameters { testModule },
             modulePlatforms = { JvmPlatform.multiTargetPlatform }
     )

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

@@ -70,8 +70,9 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
         val builtIns = JvmBuiltIns(projectContext.storageManager)
         val resolverForProject = ResolverForProjectImpl(
                 "test",
-                projectContext, modules, { JvmAnalyzerFacade },
+                projectContext, modules,
-                modulesContent = { module -> ModuleContent(module.kotlinFiles, module.javaFilesScope) },
+                { JvmAnalyzerFacade },
+                modulesContent = { module -> ModuleContent(module, module.kotlinFiles, module.javaFilesScope) },
                 platformParameters = JvmPlatformParameters {
                     javaClass ->
                     val moduleName = javaClass.name.asString().toLowerCase().first().toString()

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

@@ -39,17 +39,16 @@ import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 object JsAnalyzerFacade : ResolverForModuleFactory() {
 
     override fun <M : ModuleInfo> createResolverForModule(
-        moduleInfo: M,
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
-        moduleContent: ModuleContent,
+        moduleContent: ModuleContent<M>,
         platformParameters: PlatformAnalysisParameters,
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageSettingsProvider: LanguageSettingsProvider,
         packagePartProvider: PackagePartProvider
     ): ResolverForModule {
-        val (syntheticFiles, moduleContentScope) = moduleContent
+        val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
             project,

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

@@ -111,7 +111,7 @@ internal class ProjectResolutionFacade(
         val modulesToCreateResolversFor = allModuleInfos.filter(moduleFilter)
 
         val modulesContentFactory = { module: IdeaModuleInfo ->
-            ModuleContent(syntheticFilesByModule[module] ?: listOf(), module.contentScope())
+            ModuleContent(module, syntheticFilesByModule[module] ?: listOf(), module.contentScope())
         }
 
         val jvmPlatformParameters = JvmPlatformParameters { javaClass: JavaClass ->
@@ -132,7 +132,7 @@ internal class ProjectResolutionFacade(
             IdeaEnvironment,
             builtIns,
             delegateResolverForProject,
-            packagePartProviderFactory = { _, c -> IDEPackagePartProvider(c.moduleContentScope) },
+            packagePartProviderFactory = { moduleContent -> IDEPackagePartProvider(moduleContent.moduleContentScope) },
             firstDependency = settings.sdk?.let { SdkInfo(project, it) },
             modulePlatforms = { module -> module.platform?.multiTargetPlatform },
             packageOracleFactory = ServiceManager.getService(project, IdePackageOracleFactory::class.java),