[MPP] Introduce allModulesProviding(Expects|Actuals)For filters

This new filters will also take care of filtering out descriptors
that are provided by 'regular' dependencies instead of 'dependsOn'
dependencies.

^KT-50120

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ArgumentsUtils.kt

@@ -26,8 +26,7 @@ import org.jetbrains.kotlin.resolve.calls.model.CollectionLiteralKotlinCallArgum
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCallArgument
 import org.jetbrains.kotlin.resolve.calls.model.SimpleKotlinCallArgument
 import org.jetbrains.kotlin.resolve.descriptorUtil.isParameterOfAnnotation
-import org.jetbrains.kotlin.resolve.multiplatform.ALL_MODULES
-import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
+import org.jetbrains.kotlin.resolve.multiplatform.findCompatibleExpectsForActual
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValueWithSmartCastInfo
 import org.jetbrains.kotlin.types.UnwrappedType
 import org.jetbrains.kotlin.types.checker.intersectWrappedTypes
@@ -112,10 +111,8 @@ fun ValueParameterDescriptor.hasDefaultValue(): Boolean {
 private fun ValueParameterDescriptor.checkExpectedParameter(checker: (ValueParameterDescriptor) -> Boolean): Boolean {
     val function = containingDeclaration
     if (function is FunctionDescriptor && function.isActual) {
-        with(ExpectedActualResolver) {
-            val expected = function.findCompatibleExpectedForActual(ALL_MODULES).firstOrNull()
-            return expected is FunctionDescriptor && checker(expected.valueParameters[index])
-        }
+        val expected = function.findCompatibleExpectsForActual().firstOrNull()
+        return expected is FunctionDescriptor && checker(expected.valueParameters[index])
     }
     return false
 }

compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/ExpectedActualResolver.kt

@@ -24,24 +24,11 @@ import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.kotlin.utils.keysToMap
 
 object ExpectedActualResolver {
-    // FIXME(dsavvinov): review clients, as they won't work properly in HMPP projects
-    fun MemberDescriptor.findCompatibleActualForExpected(platformModule: ModuleDescriptor): List<MemberDescriptor> =
-        findActualForExpected(this, platformModule, onlyFromThisModule(platformModule))?.get(Compatible).orEmpty()
-
-    fun MemberDescriptor.findAnyActualForExpected(platformModule: ModuleDescriptor): List<MemberDescriptor> {
-        val actualsGroupedByCompatibility = findActualForExpected(this, platformModule, onlyFromThisModule(platformModule))
-        return actualsGroupedByCompatibility?.get(Compatible)
-                ?: actualsGroupedByCompatibility?.values?.flatten()
-                ?: emptyList()
-    }
-
-    fun MemberDescriptor.findCompatibleExpectedForActual(moduleFilter: ModuleFilter): List<MemberDescriptor> =
-        findExpectedForActual(this, moduleFilter)?.get(Compatible).orEmpty()
 
     fun findActualForExpected(
         expected: MemberDescriptor,
         platformModule: ModuleDescriptor,
-        moduleVisibilityFilter: ModuleFilter,
+        moduleVisibilityFilter: ModuleFilter = allModulesProvidingActualsFor(expected.module),
     ): Map<ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>? {
         return when (expected) {
             is CallableMemberDescriptor -> {
@@ -69,7 +56,7 @@ object ExpectedActualResolver {
 
     fun findExpectedForActual(
         actual: MemberDescriptor,
-        moduleFilter: (ModuleDescriptor) -> Boolean
+        moduleFilter: (ModuleDescriptor) -> Boolean = allModulesProvidingExpectsFor(actual.module)
     ): Map<ExpectActualCompatibility<MemberDescriptor>, List<MemberDescriptor>>? {
         return when (actual) {
             is CallableMemberDescriptor -> {
@@ -533,19 +520,39 @@ object ExpectedActualResolver {
     }
 }
 
-fun DeclarationDescriptor.findExpects(): List<MemberDescriptor> {
-    return ExpectedActualResolver.findExpectedForActual(
-        this as MemberDescriptor, ALL_MODULES
-    )?.get(Compatible).orEmpty()
+// FIXME(dsavvinov): review clients, as they won't work properly in HMPP projects
+@JvmOverloads
+fun MemberDescriptor.findCompatibleActualsForExpected(
+    platformModule: ModuleDescriptor, moduleFilter: ModuleFilter = allModulesProvidingActualsFor(module)
+): List<MemberDescriptor> =
+    ExpectedActualResolver.findActualForExpected(this, platformModule, moduleFilter)?.get(Compatible).orEmpty()
+
+@JvmOverloads
+fun MemberDescriptor.findAnyActualsForExpected(
+    platformModule: ModuleDescriptor, moduleFilter: ModuleFilter = allModulesProvidingActualsFor(module)
+): List<MemberDescriptor> {
+    val actualsGroupedByCompatibility = ExpectedActualResolver.findActualForExpected(this, platformModule, moduleFilter)
+    return actualsGroupedByCompatibility?.get(Compatible)
+        ?: actualsGroupedByCompatibility?.values?.flatten()
+        ?: emptyList()
 }
 
-fun DeclarationDescriptor.findActuals(inModule: ModuleDescriptor = this.module): List<MemberDescriptor> {
-    return ExpectedActualResolver.findActualForExpected(
-        (this as MemberDescriptor), inModule, ALL_MODULES
-    )?.get(Compatible).orEmpty()
+fun MemberDescriptor.findCompatibleExpectsForActual(
+    moduleFilter: ModuleFilter = allModulesProvidingExpectsFor(module)
+): List<MemberDescriptor> =
+    ExpectedActualResolver.findExpectedForActual(this, moduleFilter)?.get(Compatible).orEmpty()
+
+fun DeclarationDescriptor.findExpects(): List<MemberDescriptor> {
+    if(this !is MemberDescriptor) return emptyList()
+    return this.findCompatibleExpectsForActual()
+}
+
+fun DeclarationDescriptor.findActuals(inModule: ModuleDescriptor): List<MemberDescriptor> {
+    if(this !is MemberDescriptor) return emptyList()
+    return this.findCompatibleActualsForExpected(inModule)
 }
 
 // TODO: Klibs still need to better handle source in deserialized descriptors.
-val DeclarationDescriptorWithSource.couldHaveASource: Boolean get() =
-    this.source.containingFile != SourceFile.NO_SOURCE_FILE ||
-    this is DeserializedDescriptor
+val DeclarationDescriptorWithSource.couldHaveASource: Boolean
+    get() = this.source.containingFile != SourceFile.NO_SOURCE_FILE ||
+            this is DeserializedDescriptor

compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/OptionalAnnotationUtil.kt

@@ -19,9 +19,7 @@ object OptionalAnnotationUtil {
         assert(descriptor.isExpect) { "Not an expected class: $descriptor" }
 
         if (isOptionalAnnotationClass(descriptor)) {
-            with(ExpectedActualResolver) {
-                return descriptor.findCompatibleActualForExpected(descriptor.module).isEmpty()
-            }
+            return descriptor.findCompatibleActualsForExpected(descriptor.module).isEmpty()
         }
 
         return false

compiler/resolution/src/org/jetbrains/kotlin/resolve/multiplatform/moduleFilterUtils.kt

@@ -15,4 +15,12 @@ fun onlyFromThisModule(module: ModuleDescriptor): ModuleFilter = { it == module
 
 val ALL_MODULES: ModuleFilter = { true }
 
+fun allModulesProvidingExpectsFor(platformModule: ModuleDescriptor): ModuleFilter = {
+    it == platformModule || it in platformModule.allExpectedByModules
+}
+
+fun allModulesProvidingActualsFor(commonModule: ModuleDescriptor): ModuleFilter = {
+    it == commonModule || commonModule in it.allExpectedByModules
+}
+
 fun <T : DeclarationDescriptor> Iterable<T>.applyFilter(filter: ModuleFilter): List<T> = filter { filter(it.module) }