MPP: Support multiple 'expectedBy' dependencies for single module

#KT-22865 Fixed

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

@@ -239,7 +239,7 @@ interface ModuleInfo {
     val name: Name
     val displayedName: String get() = name.asString()
     fun dependencies(): List<ModuleInfo>
-    val expectedBy: ModuleInfo? get() = null
+    val expectedBy: List<ModuleInfo> get() = emptyList()
     val platform: TargetPlatform? get() = null
     fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> = listOf()
     val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
@@ -310,8 +310,8 @@ class LazyModuleDependencies<M : ModuleInfo>(
 
     override val allDependencies: List<ModuleDescriptorImpl> get() = dependencies()
 
-    override val expectedByDependency by storageManager.createNullableLazyValue {
-        module.expectedBy?.let { resolverForProject.descriptorForModule(it as M) }
+    override val expectedByDependencies by storageManager.createLazyValue {
+        module.expectedBy.map { resolverForProject.descriptorForModule(it as M) }
     }
 
     override val modulesWhoseInternalsAreVisible: Set<ModuleDescriptorImpl>

compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver.Compati
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver.Compatibility.Incompatible
 import org.jetbrains.kotlin.resolve.source.PsiSourceFile
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
+import org.jetbrains.kotlin.utils.ifEmpty
 import java.io.File
 
 object ExpectedActualDeclarationChecker : DeclarationChecker {
@@ -114,8 +115,16 @@ object ExpectedActualDeclarationChecker : DeclarationChecker {
         // However, in compiler context platform & common modules are joined into one module,
         // so there is yet no "common module" in this situation.
         // So yet we are using own module in compiler context and common module in IDE context.
-        val commonOrOwnModule = descriptor.module.expectedByModule ?: descriptor.module
-        val compatibility = ExpectedActualResolver.findExpectedForActual(descriptor, commonOrOwnModule) ?: return
+        val commonOrOwnModules = descriptor.module.expectedByModules.ifEmpty { listOf(descriptor.module) }
+        val compatibility = commonOrOwnModules
+            .asSequence()
+            .fold(LinkedHashMap<Compatibility, List<MemberDescriptor>>()) { resultMap, commonModule ->
+                val currentMap = ExpectedActualResolver.findExpectedForActual(descriptor, commonModule)
+                if (currentMap != null) {
+                    resultMap.putAll(currentMap)
+                }
+                resultMap
+            }
 
         val hasActualModifier = descriptor.isActual && reportOn.hasActualModifier()
         if (!hasActualModifier) {