[FIR] Discriminate abstract members when resolving on super

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt

@@ -22,7 +22,8 @@ class ConeEquivalentCallConflictResolver(
 ) : AbstractConeCallConflictResolver(specificityComparator, inferenceComponents) {
     override fun chooseMaximallySpecificCandidates(
         candidates: Set<Candidate>,
-        discriminateGenerics: Boolean
+        discriminateGenerics: Boolean,
+        discriminateAbstracts: Boolean
     ): Set<Candidate> {
         return filterOutEquivalentCalls(candidates)
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedReifiedParameterRefe
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.references.impl.FirBackingFieldReferenceImpl
 import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.references.impl.FirResolvedNamedReferenceImpl
@@ -139,7 +140,10 @@ class FirCallResolver(
         val reducedCandidates = if (result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED) {
             bestCandidates.toSet()
         } else {
-            conflictResolver.chooseMaximallySpecificCandidates(bestCandidates, discriminateGenerics = true)
+            val onSuperReference = (functionCall.explicitReceiver as? FirQualifiedAccessExpression)?.calleeReference is FirSuperReference
+            conflictResolver.chooseMaximallySpecificCandidates(
+                bestCandidates, discriminateGenerics = true, discriminateAbstracts = onSuperReference
+            )
         }
         return ResolutionResult(info, result.currentApplicability, reducedCandidates)
     }
@@ -176,7 +180,10 @@ class FirCallResolver(
         val reducedCandidates = if (result.currentApplicability < CandidateApplicability.SYNTHETIC_RESOLVED) {
             bestCandidates.toSet()
         } else {
-            conflictResolver.chooseMaximallySpecificCandidates(bestCandidates, discriminateGenerics = false)
+            val onSuperReference = (qualifiedAccess.explicitReceiver as? FirQualifiedAccessExpression)?.calleeReference is FirSuperReference
+            conflictResolver.chooseMaximallySpecificCandidates(
+                bestCandidates, discriminateGenerics = false, discriminateAbstracts = onSuperReference
+            )
         }
         val nameReference = createResolvedNamedReference(
             callee,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCallConflictResolver.kt

@@ -13,16 +13,19 @@ import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
 abstract class ConeCallConflictResolver {
     fun chooseMaximallySpecificCandidates(
         candidates: Collection<Candidate>,
-        discriminateGenerics: Boolean
-    ): Set<Candidate> = chooseMaximallySpecificCandidates(candidates.toSet(), discriminateGenerics)
+        discriminateGenerics: Boolean,
+        discriminateAbstracts: Boolean = false
+    ): Set<Candidate> = chooseMaximallySpecificCandidates(candidates.toSet(), discriminateGenerics, discriminateAbstracts)
 
     abstract fun chooseMaximallySpecificCandidates(
         candidates: Set<Candidate>,
-        discriminateGenerics: Boolean
+        discriminateGenerics: Boolean,
+        discriminateAbstracts: Boolean
     ): Set<Candidate>
 }
 
 abstract class ConeCallConflictResolverFactory : FirSessionComponent {
     abstract fun create(typeSpecificityComparator: TypeSpecificityComparator, components: InferenceComponents): ConeCallConflictResolver
 }
+
 val FirSession.callConflictResolverFactory by componentArrayAccessor<ConeCallConflictResolverFactory>()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCompositeConflictResolver.kt

@@ -8,13 +8,17 @@ package org.jetbrains.kotlin.fir.resolve.calls
 class ConeCompositeConflictResolver(
     private vararg val conflictResolvers: AbstractConeCallConflictResolver
 ) : ConeCallConflictResolver() {
-    override fun chooseMaximallySpecificCandidates(candidates: Set<Candidate>, discriminateGenerics: Boolean): Set<Candidate> {
+    override fun chooseMaximallySpecificCandidates(
+        candidates: Set<Candidate>,
+        discriminateGenerics: Boolean,
+        discriminateAbstracts: Boolean
+    ): Set<Candidate> {
         if (candidates.size <= 1) return candidates
         var currentCandidates = candidates
         var index = 0
         while (currentCandidates.size > 1 && index < conflictResolvers.size) {
             val conflictResolver = conflictResolvers[index++]
-            currentCandidates = conflictResolver.chooseMaximallySpecificCandidates(candidates, discriminateGenerics)
+            currentCandidates = conflictResolver.chooseMaximallySpecificCandidates(candidates, discriminateGenerics, discriminateAbstracts)
         }
         return currentCandidates
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeOverloadConflictResolver.kt

@@ -5,6 +5,9 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls
 
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
+import org.jetbrains.kotlin.fir.declarations.modality
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -27,14 +30,18 @@ class ConeOverloadConflictResolver(
 
     override fun chooseMaximallySpecificCandidates(
         candidates: Set<Candidate>,
-        discriminateGenerics: Boolean
+        discriminateGenerics: Boolean,
+        discriminateAbstracts: Boolean
     ): Set<Candidate> {
-        return chooseMaximallySpecificCandidates(candidates, discriminateGenerics, discriminateSAMs = true)
+        return chooseMaximallySpecificCandidates(
+            candidates, discriminateGenerics, discriminateAbstracts, discriminateSAMs = true
+        )
     }
 
     private fun chooseMaximallySpecificCandidates(
         candidates: Set<Candidate>,
         discriminateGenerics: Boolean,
+        discriminateAbstracts: Boolean,
         discriminateSAMs: Boolean
     ): Set<Candidate> {
         findMaximallySpecificCall(candidates, false)?.let { return setOf(it) }
@@ -49,7 +56,21 @@ class ConeOverloadConflictResolver(
                 1 -> return filtered
                 0, candidates.size -> {
                 }
-                else -> return chooseMaximallySpecificCandidates(filtered, discriminateGenerics, discriminateSAMs = false)
+                else -> return chooseMaximallySpecificCandidates(
+                    filtered, discriminateGenerics, discriminateAbstracts, discriminateSAMs = false
+                )
+            }
+        }
+
+        if (discriminateAbstracts) {
+            val filtered = candidates.filterTo(mutableSetOf()) { (it.symbol.fir as? FirMemberDeclaration)?.modality != Modality.ABSTRACT }
+            when (filtered.size) {
+                1 -> return filtered
+                0, candidates.size -> {
+                }
+                else -> return chooseMaximallySpecificCandidates(
+                    filtered, discriminateGenerics, discriminateAbstracts = false, discriminateSAMs = false
+                )
             }
         }
 

compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.kt

@@ -17,7 +17,7 @@ class C : A, B() {
 
         super.<!AMBIGUITY!>bar<!>() // should be ambiguity (NB: really we should have overridden bar in C)
 
-        super.<!AMBIGUITY!>baz<!>() // Ok
+        super.baz() // Ok
         baz()       // Ok
     }
 }

compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.txt

@@ -29,7 +29,7 @@ FILE: incorrectSuperCall.kt
         public final override fun foo(): R|kotlin/Unit| {
             super<R|A|R|B|>.R|/B.foo|()
             super<R|A|R|B|>.<Ambiguity: bar, [/A.bar, /B.bar]>#()
-            super<R|A|R|B|>.<Ambiguity: baz, [/A.baz, /B.baz]>#()
+            super<R|A|R|B|>.R|/B.baz|()
             this@R|/C|.R|/A.baz|()
         }