[Commonizer] Refactor ModulesProvider.loadModuleInfos() function

Change return type from Map<String, ModuleInfo> to Collection<ModuleInfo>

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/CommonizerParameters.kt

@@ -42,7 +42,7 @@ class CommonizerParameters(
         if (_targetProviders.size < 2) return false // too few targets
 
         val allModuleNames: List<Set<String>> = _targetProviders.values.map { targetProvider ->
-            targetProvider.modulesProvider.loadModuleInfos().keys
+            targetProvider.modulesProvider.loadModuleInfos().mapTo(HashSet()) { it.name }
         }
         val commonModuleNames: Set<String> = allModuleNames.reduce { a, b -> a intersect b }
 

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/TargetProvider.kt

@@ -26,6 +26,6 @@ interface ModulesProvider {
         val exportForwardDeclarations: Collection<String>
     )
 
-    fun loadModuleInfos(): Map<String, ModuleInfo>
+    fun loadModuleInfos(): Collection<ModuleInfo>
     fun loadModules(dependencies: Collection<ModuleDescriptor>): Map<String, ModuleDescriptor>
 }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/konan/NativeDistributionModulesProvider.kt

@@ -23,8 +23,8 @@ internal class NativeDistributionModulesProvider(
     private val storageManager: StorageManager,
     private val librariesToCommonize: NativeLibrariesToCommonize
 ) : ModulesProvider {
-    private val moduleInfos: Map<String, ModuleInfo> by lazy {
+    private val moduleInfos by lazy {
-        librariesToCommonize.libraries.associate { library ->
+        librariesToCommonize.libraries.map { library ->
             val manifestData = library.manifestData
 
             val name = manifestData.uniqueName
@@ -38,11 +38,11 @@ internal class NativeDistributionModulesProvider(
                 CInteropModuleAttributes(packageFqName, manifestData.exportForwardDeclarations)
             } else null
 
-            name to ModuleInfo(name, location, cInteropAttributes)
+            ModuleInfo(name, location, cInteropAttributes)
         }
     }
 
-    override fun loadModuleInfos(): Map<String, ModuleInfo> = moduleInfos
+    override fun loadModuleInfos() = moduleInfos
 
     override fun loadModules(dependencies: Collection<ModuleDescriptor>): Map<String, ModuleDescriptor> {
         check(dependencies.isNotEmpty()) { "At least Kotlin/Native stdlib should be provided" }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/konan/NativeDistributionStdlibProvider.kt

@@ -24,7 +24,7 @@ internal class NativeDistributionStdlibProvider(
         cInteropAttributes = null
     )
 
-    override fun loadModuleInfos(): Map<String, ModuleInfo> = mapOf(KONAN_STDLIB_NAME to moduleInfo)
+    override fun loadModuleInfos() = listOf(moduleInfo)
 
     override fun loadModules(dependencies: Collection<ModuleDescriptor>): Map<String, ModuleDescriptor> {
         check(dependencies.isEmpty())

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt

@@ -68,12 +68,14 @@ class CirTreeMerger(
         val rootNode: CirRootNode = buildRootNode(storageManager, size)
 
         // remember any exported forward declarations from common fragments of dependee modules
-        parameters.dependeeModulesProvider?.loadModuleInfos()?.values?.forEach(::processCInteropModuleAttributes)
+        parameters.dependeeModulesProvider?.loadModuleInfos()?.forEach(::processCInteropModuleAttributes)
 
         // load common dependencies
         val dependeeModules = parameters.dependeeModulesProvider?.loadModules(emptyList())?.values.orEmpty()
 
-        val allModuleInfos: List<Map<String, ModuleInfo>> = parameters.targetProviders.map { it.modulesProvider.loadModuleInfos() }
+        val allModuleInfos: List<Map<String, ModuleInfo>> = parameters.targetProviders.map { targetProvider ->
+            targetProvider.modulesProvider.loadModuleInfos().associateBy { it.name }
+        }
         val commonModuleNames = allModuleInfos.map { it.keys }.reduce { a, b -> a intersect b }
 
         parameters.targetProviders.forEachIndexed { targetIndex, targetProvider ->

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/mocks.kt

@@ -152,7 +152,7 @@ internal val MOCK_CLASSIFIERS = CirKnownClassifiers(
 internal class MockModulesProvider private constructor(
     private val modules: Map<String, ModuleDescriptor>,
 ) : ModulesProvider {
-    private val moduleInfos: Map<String, ModuleInfo> = modules.mapValues { (name, _) -> fakeModuleInfo(name) }
+    private val moduleInfos = modules.keys.map { name -> fakeModuleInfo(name) }
 
     override fun loadModuleInfos() = moduleInfos
     override fun loadModules(dependencies: Collection<ModuleDescriptor>): Map<String, ModuleDescriptor> = modules