Rework method disambiguator

SemanticDB and SCIP don't disambiguate methods by adding their full
signature, instead they sort overloaded methods by declaration order,
the first one is `method().`, the next one is `method(+1).`, the next
one `method(+2).` etc.

Down to 14 failing tests.

Author: nicolas-guichard

semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SymbolsCache.kt

@@ -6,16 +6,16 @@ import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isLocalMember
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingSymbol
+import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
-import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.utils.memberDeclarationNameOrNull
 import org.jetbrains.kotlin.fir.declarations.utils.nameOrSpecialName
 import org.jetbrains.kotlin.fir.packageFqName
 import org.jetbrains.kotlin.fir.resolve.getContainingDeclaration
+import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
-import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
 
@@ -163,44 +163,37 @@ class GlobalSymbolsCache(testing: Boolean = false) : Iterable<Symbol> {
     }
 
     @OptIn(SymbolInternals::class)
-    fun disambiguateCallableSymbol(callableSymbol: FirCallableSymbol<*>): String {
-        val callableId = callableSymbol.callableId
-        val callableName = callableId.callableName.asString()
-        val fqName = callableId.packageName.asString()
-
-        // Get the FIR element associated with the callable symbol
-        val firFunction = callableSymbol.fir as? FirFunction ?: return "$fqName.$callableName"
-
-        // Get parameter types from the function's value parameters
-        val parameterTypes =
-            firFunction.valueParameters.joinToString(separator = ", ") {
-                it.returnTypeRef.coneType.render()
+    private fun methodDisambiguator(symbol: FirFunctionSymbol<*>): String {
+        val session = symbol.moduleData.session
+
+        val siblings =
+            when (val containingSymbol = symbol.getContainingSymbol(session)) {
+                is FirClassSymbol ->
+                    (containingSymbol.fir as FirClass).declarations.map { it.symbol }
+                is FirFileSymbol -> containingSymbol.fir.declarations.map { it.symbol }
+                null ->
+                    symbol.moduleData.session.symbolProvider.getTopLevelCallableSymbols(
+                        symbol.packageFqName(), symbol.name)
+                else -> return "()"
             }
 
-        // Get the return type (for functions and properties)
-        val returnType = firFunction.returnTypeRef.coneType.render()
-
-        // Create a string representing the fully qualified name + signature
-        return "$fqName.$callableName($parameterTypes): $returnType"
-    }
+        var count = 0
+        var found = false
+        for (decl in siblings) {
+            if (decl == symbol) {
+                found = true
+                break
+            }
 
-    // Extension function to render a ConeKotlinType to a string
-    private fun ConeKotlinType?.render(): String = this?.toString() ?: "Unit"
+            if (decl.memberDeclarationNameOrNull?.equals(symbol.name) == true) {
+                count++
+            }
+        }
 
-    private fun disambiguateClassSymbol(classSymbol: FirClassSymbol<*>): String {
-        val classId = classSymbol.classId
-        val fqName = classId.asString()
-        // You can also add additional details like visibility or modifiers if needed
-        return "class $fqName"
+        if (count == 0 || !found) return "()"
+        return "(+${count})"
     }
 
-    private fun methodDisambiguator(symbol: FirBasedSymbol<*>): String =
-        when (symbol) {
-            is FirCallableSymbol<*> -> disambiguateCallableSymbol(symbol)
-            is FirClassSymbol<*> -> disambiguateClassSymbol(symbol)
-            else -> "()"
-        }
-
     override fun iterator(): Iterator<Symbol> = globals.values.iterator()
 }
 

semanticdb-kotlinc/src/test/kotlin/com/sourcegraph/semanticdb_kotlinc/test/SemanticdbSymbolsTest.kt

@@ -183,8 +183,8 @@ class SemanticdbSymbolsTest {
                     symbolsCacheData =
                         SymbolCacheData(
                             listOf(
-                                "kotlin/collections/mapOf(+1).".symbol(),
-                                "kotlin/io/println().".symbol()))))
+                                "kotlin/collections/mapOf(+2).".symbol(),
+                                "kotlin/io/println(+10).".symbol()))))
             .mapCheckExpectedSymbols()
 
     @TestFactory