[Analysis API] Introduce KaSymbolRelationProvider.hasConflictingSignatureWith

^KT-74009 fixed

Author: BlaBlaHuman

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KaFe10SymbolRelationProvider.kt

@@ -35,13 +35,18 @@ import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
 import org.jetbrains.kotlin.load.kotlin.asNioPath
 import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.hasActualModifier
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.OverloadChecker
+import org.jetbrains.kotlin.resolve.calls.components.ClassicTypeSystemContextForCS
+import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
 import org.jetbrains.kotlin.resolve.descriptorUtil.denotedClassDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.platform
 import org.jetbrains.kotlin.resolve.findOriginalTopMostOverriddenDescriptors
+import org.jetbrains.kotlin.resolve.jvm.JvmTypeSpecificityComparatorDelegate
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectedActualResolver
 import org.jetbrains.kotlin.resolve.multiplatform.isCompatibleOrWeaklyIncompatible
 import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor
@@ -260,6 +265,24 @@ internal class KaFe10SymbolRelationProvider(
             return inheritorsProvider.computeSealedSubclasses(classDescriptor, allowInDifferentFiles)
                 .mapNotNull { it.toKtClassifierSymbol(analysisContext) as? KaNamedClassSymbol }
         }
+
+    override fun KaFunctionSymbol.hasConflictingSignatureWith(other: KaFunctionSymbol, targetPlatform: TargetPlatform): Boolean =
+        withValidityAssertion {
+            val thisDescriptor = getDescriptor() ?: return false
+            val otherDescriptor = other.getDescriptor() ?: return false
+
+            val typeSpecificityComparator = when {
+                targetPlatform.isJvm() -> JvmTypeSpecificityComparatorDelegate(
+                    ClassicTypeSystemContextForCS(
+                        analysisContext.builtIns,
+                        analysisContext.kotlinTypeRefiner
+                    )
+                )
+                else -> TypeSpecificityComparator.NONE
+            }
+
+            !OverloadChecker(typeSpecificityComparator).isOverloadable(thisDescriptor, otherDescriptor)
+        }
 }
 
 internal fun computeContainingSymbolOrSelf(symbol: KaSymbol, analysisSession: KaSession): KaSymbol = with(analysisSession) {

analysis/analysis-api-fe10/tests-gen/org/jetbrains/kotlin/analysis/api/fe10/test/cases/generated/cases/components/relationProvider/Fe10IdeNormalAnalysisSourceModuleHasConflictingSignatureWithTestGenerated.java

@@ -31,16 +31,16 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.utils.printer.parentOfType
-import org.jetbrains.kotlin.fir.FirElementWithResolveState
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.resolve.getContainingClassSymbol
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.getImplementationStatus
-import org.jetbrains.kotlin.fir.containingClassForLocalAttr
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOverloadabilityHelper.ContextParameterShadowing.BothWays
 import org.jetbrains.kotlin.fir.diagnostics.ConeDestructuringDeclarationsOnTopLevel
 import org.jetbrains.kotlin.fir.resolve.FirSamResolver
 import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
 import org.jetbrains.kotlin.fir.resolve.calls.FirSimpleSyntheticPropertySymbol
+import org.jetbrains.kotlin.fir.resolve.getContainingClassSymbol
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.impl.typeAliasConstructorInfo
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -49,9 +49,10 @@ import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.classId
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.toLookupTag
-import org.jetbrains.kotlin.fir.unwrapFakeOverridesOrDelegated
 import org.jetbrains.kotlin.fir.utils.exceptions.withFirSymbolEntry
 import org.jetbrains.kotlin.ir.util.kotlinPackageFqn
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.psi
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
@@ -460,4 +461,55 @@ internal class KaFirSymbolRelationProvider(
                 inheritorClassIds.mapNotNull { findClass(it) as? KaNamedClassSymbol }
             }
         }
+
+    override fun KaFunctionSymbol.hasConflictingSignatureWith(other: KaFunctionSymbol, targetPlatform: TargetPlatform): Boolean =
+        withValidityAssertion {
+            val thisFirSymbol = firSymbol
+            val otherFirSymbol = other.firSymbol
+
+            val thisHasLowPriority = hasLowPriorityAnnotation(thisFirSymbol.resolvedAnnotationsWithClassIds)
+            val otherHasLowPriority = hasLowPriorityAnnotation(otherFirSymbol.resolvedAnnotationsWithClassIds)
+            if (thisHasLowPriority != otherHasLowPriority) {
+                return false
+            }
+
+            /**
+             * [FirDeclarationOverloadabilityHelper] performs signature comparison only from JVM platform perspective.
+             * However, as the API needs to be more generic than that, here we perform manual signature comparison
+             * before calling [FirDeclarationOverloadabilityHelper].
+             * This is done to handle cases which are considered conflicting on JVM but completely valid on other platforms:
+             * - Overloads by type parameters
+             * ```kotlin
+             * fun <T> foo() // Conflicting on JVM, valid on other platforms
+             * fun foo()
+             * ```
+             * - Overloads by vararg/array parameters
+             * ```kotlin
+             * fun foo(vararg ints: Int) // Conflicting on JVM, valid on other platforms
+             * fun foo(ints: IntArray)
+             * ```
+             */
+            if (!targetPlatform.isJvm()) {
+                if (thisFirSymbol.typeParameterSymbols.isEmpty() != otherFirSymbol.typeParameterSymbols.isEmpty()) {
+                    return false
+                }
+
+                val thisVarargParameterPosition = valueParameters.indexOfFirst { it.isVararg }
+                val otherVarargParameterPosition = other.valueParameters.indexOfFirst { it.isVararg }
+                if (thisVarargParameterPosition != otherVarargParameterPosition) {
+                    return false
+                }
+            }
+
+            val overloadabilityHelper = analysisSession.firSession.declarationOverloadabilityHelper
+
+            return if (analysisSession.firSession.languageVersionSettings.supportsFeature(LanguageFeature.ContextParameters)) {
+                return overloadabilityHelper.getContextParameterShadowing(thisFirSymbol, otherFirSymbol) == BothWays
+            } else {
+                overloadabilityHelper.isConflicting(
+                    thisFirSymbol,
+                    otherFirSymbol,
+                )
+            }
+        }
 }