Fix class and function overridden symbols

nicolas-guichard · antonsviridov-src · commit a75b0937c90f · 2025-06-30T15:33:53.000+01:00
Class overriddenSymbols were not pointing to actual symbols.

Function overriddenSymbols were missing.
diff --git a/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/AnalyzerCheckers.kt b/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/AnalyzerCheckers.kt
@@ -131,7 +131,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
                 val names = source.treeStructure.findLastDescendant(source.lighterASTNode) { true }
                 if (names != null) {
                     eachFqNameElement(fqName, source.treeStructure, names) { fqName, name ->
-                        visitor?.visitPackage(fqName, name)
+                        visitor?.visitPackage(fqName, name, context)
                     }
                 }
             }
@@ -152,13 +152,13 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
                                 fqName.parent(), fqName.shortName())
 
                         if (klass != null) {
-                            visitor?.visitClassReference(klass, name)
+                            visitor?.visitClassReference(klass, name, context)
                         } else if (callables.isNotEmpty()) {
                             for (callable in callables) {
-                                visitor?.visitCallableReference(callable, name)
+                                visitor?.visitCallableReference(callable, name, context)
                             }
                         } else {
-                            visitor?.visitPackage(fqName, name)
+                            visitor?.visitPackage(fqName, name, context)
                         }
                     }
                 }
@@ -176,7 +176,15 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitClassOrObject(declaration, getIdentifier(source))
+            visitor?.visitClassOrObject(declaration, getIdentifier(source), context)
+
+            for (superType in declaration.superTypeRefs) {
+                val superSymbol = superType.toClassLikeSymbol(context.session)
+                val superSource = superType.source
+                if (superSymbol != null && superSource != null) {
+                    visitor?.visitClassReference(superSymbol, superSource, context)
+                }
+            }
         }
     }
 
@@ -202,9 +210,9 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
                         .findChildByType(source.lighterASTNode, KtTokens.CONSTRUCTOR_KEYWORD)
                         ?.toKtLightSourceElement(source.treeStructure)
 
-                visitor?.visitPrimaryConstructor(declaration, constructorKeyboard ?: getIdentifier(klassSource))
+                visitor?.visitPrimaryConstructor(declaration, constructorKeyboard ?: getIdentifier(klassSource), context)
             } else {
-                visitor?.visitSecondaryConstructor(declaration, getIdentifier(source))
+                visitor?.visitSecondaryConstructor(declaration, getIdentifier(source), context)
             }
         }
     }
@@ -219,7 +227,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitNamedFunction(declaration, getIdentifier(source))
+            visitor?.visitNamedFunction(declaration, getIdentifier(source), context)
         }
     }
 
@@ -234,7 +242,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitNamedFunction(declaration, source)
+            visitor?.visitNamedFunction(declaration, source, context)
         }
     }
 
@@ -248,12 +256,12 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitProperty(declaration, getIdentifier(source))
+            visitor?.visitProperty(declaration, getIdentifier(source), context)
 
             val klass = declaration.returnTypeRef.toClassLikeSymbol(context.session)
             val klassSource = declaration.returnTypeRef.source
             if (klass != null && klassSource != null) {
-                visitor?.visitClassReference(klass, getIdentifier(klassSource))
+                visitor?.visitClassReference(klass, getIdentifier(klassSource), context)
             }
         }
     }
@@ -268,7 +276,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitParameter(declaration, getIdentifier(source))
+            visitor?.visitParameter(declaration, getIdentifier(source), context)
         }
     }
 
@@ -282,7 +290,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitTypeParameter(declaration, getIdentifier(source))
+            visitor?.visitTypeParameter(declaration, getIdentifier(source), context)
         }
     }
 
@@ -296,7 +304,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             val source = declaration.source ?: return
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitTypeAlias(declaration, getIdentifier(source))
+            visitor?.visitTypeAlias(declaration, getIdentifier(source), context)
         }
     }
 
@@ -328,7 +336,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
                     getIdentifier(source)
                 }
 
-            visitor?.visitPropertyAccessor(declaration, identifierSource)
+            visitor?.visitPropertyAccessor(declaration, identifierSource, context)
         }
     }
 
@@ -348,23 +356,23 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
 
             val ktFile = context.containingFile?.sourceFile ?: return
             val visitor = visitors[ktFile]
-            visitor?.visitSimpleNameExpression(calleeReference, getIdentifier(calleeReference.source ?: source))
+            visitor?.visitSimpleNameExpression(calleeReference, getIdentifier(calleeReference.source ?: source), context)
 
             val resolvedSymbol = calleeReference.resolvedSymbol
             if (resolvedSymbol.origin == FirDeclarationOrigin.SamConstructor && resolvedSymbol is FirSyntheticFunctionSymbol) {
                 val referencedKlass = resolvedSymbol.resolvedReturnType.toClassLikeSymbol(context.session)
                 if (referencedKlass != null) {
-                    visitor?.visitClassReference(referencedKlass, getIdentifier(calleeReference.source ?: source))
+                    visitor?.visitClassReference(referencedKlass, getIdentifier(calleeReference.source ?: source), context)
                 }
             }
 
             // When encountering a reference to a property symbol, emit both getter and setter symbols
             if (resolvedSymbol is FirPropertySymbol) {
                 resolvedSymbol.getterSymbol?.let {
-                    visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source))
+                    visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source), context)
                 }
                 resolvedSymbol.setterSymbol?.let {
-                    visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source))
+                    visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source), context)
                 }
             }
         }
diff --git a/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SemanticdbTextDocumentBuilder.kt b/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SemanticdbTextDocumentBuilder.kt
@@ -9,6 +9,9 @@ import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.com.intellij.lang.java.JavaLanguage
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.getDirectOverriddenSymbols
+import org.jetbrains.kotlin.fir.analysis.checkers.toClassLikeSymbol
 import org.jetbrains.kotlin.fir.analysis.getChild
 import org.jetbrains.kotlin.fir.renderer.*
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -24,7 +27,8 @@ import org.jetbrains.kotlin.text
 class SemanticdbTextDocumentBuilder(
     private val sourceroot: Path,
     private val file: KtSourceFile,
-    private val lineMap: LineMap
+    private val lineMap: LineMap,
+    private val cache: SymbolsCache,
 ) {
     private val occurrences = mutableListOf<Semanticdb.SymbolOccurrence>()
     private val symbols = mutableListOf<Semanticdb.SymbolInformation>()
@@ -46,14 +50,15 @@ class SemanticdbTextDocumentBuilder(
         firBasedSymbol: FirBasedSymbol<*>?,
         symbol: Symbol,
         element: KtSourceElement,
-        role: Role
+        role: Role,
+        context: CheckerContext,
     ) {
         symbolOccurrence(symbol, element, role).let {
             if (!occurrences.contains(it)) {
                 occurrences.add(it)
             }
         }
-        val symbolInformation = symbolInformation(firBasedSymbol, symbol, element)
+        val symbolInformation = symbolInformation(firBasedSymbol, symbol, element, context)
         if (role == Role.DEFINITION && !symbols.contains(symbolInformation))
             symbols.add(symbolInformation)
     }
@@ -62,17 +67,21 @@ class SemanticdbTextDocumentBuilder(
     private fun symbolInformation(
         firBasedSymbol: FirBasedSymbol<*>?,
         symbol: Symbol,
-        element: KtSourceElement
+        element: KtSourceElement,
+        context: CheckerContext,
     ): Semanticdb.SymbolInformation {
         val supers =
             when (firBasedSymbol) {
                 is FirClassSymbol ->
                     firBasedSymbol
                         .resolvedSuperTypeRefs
                         .filter { it !is FirImplicitAnyTypeRef }
-                        .map { it.toString() }
-                        .asIterable()
-                else -> emptyList<String>().asIterable()
+                        .map { it.toClassLikeSymbol(firBasedSymbol.moduleData.session) }
+                        .filterNotNull()
+                        .flatMap { cache[it] }
+                is FirFunctionSymbol<*> ->
+                    firBasedSymbol.fir.getDirectOverriddenSymbols(context).flatMap { cache[it] }
+                else -> emptyList<Symbol>().asIterable()
             }
         return SymbolInformation {
             this.symbol = symbol.toString()
@@ -91,7 +100,7 @@ class SemanticdbTextDocumentBuilder(
                         message = ""
                     }
                 }
-            this.addAllOverriddenSymbols(supers)
+            this.addAllOverriddenSymbols(supers.map { it.toString() })
             this.language =
                 when (element.psi?.language ?: KotlinLanguage.INSTANCE) {
                     is KotlinLanguage -> Semanticdb.Language.KOTLIN
diff --git a/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SemanticdbVisitor.kt b/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SemanticdbVisitor.kt
@@ -5,6 +5,7 @@ import java.nio.file.Path
 import kotlin.contracts.ExperimentalContracts
 import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.KtSourceFile
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -21,7 +22,7 @@ class SemanticdbVisitor(
     locals: LocalSymbolsCache = LocalSymbolsCache()
 ) {
     private val cache = SymbolsCache(globals, locals)
-    private val documentBuilder = SemanticdbTextDocumentBuilder(sourceroot, file, lineMap)
+    private val documentBuilder = SemanticdbTextDocumentBuilder(sourceroot, file, lineMap, cache)
 
     private data class SymbolDescriptorPair(
         val firBasedSymbol: FirBasedSymbol<*>?,
@@ -34,78 +35,79 @@ class SemanticdbVisitor(
 
     private fun Sequence<SymbolDescriptorPair>?.emitAll(
         element: KtSourceElement,
-        role: Role
+        role: Role,
+        context: CheckerContext,
     ): List<Symbol>? =
         this?.onEach { (firBasedSymbol, symbol) ->
-                documentBuilder.emitSemanticdbData(firBasedSymbol, symbol, element, role)
+                documentBuilder.emitSemanticdbData(firBasedSymbol, symbol, element, role, context)
             }
             ?.map { it.symbol }
             ?.toList()
 
     private fun Sequence<Symbol>.with(firBasedSymbol: FirBasedSymbol<*>?) =
         this.map { SymbolDescriptorPair(firBasedSymbol, it) }
 
-    fun visitPackage(pkg: FqName, element: KtSourceElement) {
-        cache[pkg].with(null).emitAll(element, Role.REFERENCE)
+    fun visitPackage(pkg: FqName, element: KtSourceElement, context: CheckerContext) {
+        cache[pkg].with(null).emitAll(element, Role.REFERENCE, context)
     }
 
-    fun visitClassReference(firClassSymbol: FirClassLikeSymbol<*>, element: KtSourceElement) {
-        cache[firClassSymbol].with(firClassSymbol).emitAll(element, Role.REFERENCE)
+    fun visitClassReference(firClassSymbol: FirClassLikeSymbol<*>, element: KtSourceElement, context: CheckerContext) {
+        cache[firClassSymbol].with(firClassSymbol).emitAll(element, Role.REFERENCE, context)
     }
 
-    fun visitCallableReference(firClassSymbol: FirCallableSymbol<*>, element: KtSourceElement) {
-        cache[firClassSymbol].with(firClassSymbol).emitAll(element, Role.REFERENCE)
+    fun visitCallableReference(firClassSymbol: FirCallableSymbol<*>, element: KtSourceElement, context: CheckerContext) {
+        cache[firClassSymbol].with(firClassSymbol).emitAll(element, Role.REFERENCE, context)
     }
 
-    fun visitClassOrObject(firClass: FirClass, element: KtSourceElement) {
-        cache[firClass.symbol].with(firClass.symbol).emitAll(element, Role.DEFINITION)
+    fun visitClassOrObject(firClass: FirClass, element: KtSourceElement, context: CheckerContext) {
+        cache[firClass.symbol].with(firClass.symbol).emitAll(element, Role.DEFINITION, context)
     }
 
-    fun visitPrimaryConstructor(firConstructor: FirConstructor, source: KtSourceElement) {
+    fun visitPrimaryConstructor(firConstructor: FirConstructor, source: KtSourceElement, context: CheckerContext) {
         // if the constructor is not denoted by the 'constructor' keyword, we want to link it to the
         // class ident
-        cache[firConstructor.symbol].with(firConstructor.symbol).emitAll(source, Role.DEFINITION)
+        cache[firConstructor.symbol].with(firConstructor.symbol).emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitSecondaryConstructor(firConstructor: FirConstructor, source: KtSourceElement) {
-        cache[firConstructor.symbol].with(firConstructor.symbol).emitAll(source, Role.DEFINITION)
+    fun visitSecondaryConstructor(firConstructor: FirConstructor, source: KtSourceElement, context: CheckerContext) {
+        cache[firConstructor.symbol].with(firConstructor.symbol).emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitNamedFunction(firFunction: FirFunction, source: KtSourceElement) {
-        cache[firFunction.symbol].with(firFunction.symbol).emitAll(source, Role.DEFINITION)
+    fun visitNamedFunction(firFunction: FirFunction, source: KtSourceElement, context: CheckerContext) {
+        cache[firFunction.symbol].with(firFunction.symbol).emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitProperty(firProperty: FirProperty, source: KtSourceElement) {
-        cache[firProperty.symbol].with(firProperty.symbol).emitAll(source, Role.DEFINITION)
+    fun visitProperty(firProperty: FirProperty, source: KtSourceElement, context: CheckerContext) {
+        cache[firProperty.symbol].with(firProperty.symbol).emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitParameter(firParameter: FirValueParameter, source: KtSourceElement) {
-        cache[firParameter.symbol].with(firParameter.symbol).emitAll(source, Role.DEFINITION)
+    fun visitParameter(firParameter: FirValueParameter, source: KtSourceElement, context: CheckerContext) {
+        cache[firParameter.symbol].with(firParameter.symbol).emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitTypeParameter(firTypeParameter: FirTypeParameter, source: KtSourceElement) {
+    fun visitTypeParameter(firTypeParameter: FirTypeParameter, source: KtSourceElement, context: CheckerContext) {
         cache[firTypeParameter.symbol]
             .with(firTypeParameter.symbol)
-            .emitAll(source, Role.DEFINITION)
+            .emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitTypeAlias(firTypeAlias: FirTypeAlias, source: KtSourceElement) {
-        cache[firTypeAlias.symbol].with(firTypeAlias.symbol).emitAll(source, Role.DEFINITION)
+    fun visitTypeAlias(firTypeAlias: FirTypeAlias, source: KtSourceElement, context: CheckerContext) {
+        cache[firTypeAlias.symbol].with(firTypeAlias.symbol).emitAll(source, Role.DEFINITION, context)
     }
 
-    fun visitPropertyAccessor(firPropertyAccessor: FirPropertyAccessor, source: KtSourceElement) {
+    fun visitPropertyAccessor(firPropertyAccessor: FirPropertyAccessor, source: KtSourceElement, context: CheckerContext) {
         cache[firPropertyAccessor.symbol]
             .with(firPropertyAccessor.symbol)
-            .emitAll(source, Role.DEFINITION)
+            .emitAll(source, Role.DEFINITION, context)
     }
 
     fun visitSimpleNameExpression(
         firResolvedNamedReference: FirResolvedNamedReference,
-        source: KtSourceElement
+        source: KtSourceElement, context: CheckerContext,
     ) {
         cache[firResolvedNamedReference.resolvedSymbol]
             .with(firResolvedNamedReference.resolvedSymbol)
-            .emitAll(source, Role.REFERENCE)
+            .emitAll(source, Role.REFERENCE, context)
     }
 }
 
diff --git a/semanticdb-kotlinc/src/test/kotlin/com/sourcegraph/semanticdb_kotlinc/test/AnalyzerTest.kt b/semanticdb-kotlinc/src/test/kotlin/com/sourcegraph/semanticdb_kotlinc/test/AnalyzerTest.kt

Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`131`	`131`	`val names = source.treeStructure.findLastDescendant(source.lighterASTNode) { true }`
`132`	`132`	`if (names != null) {`
`133`	`133`	`eachFqNameElement(fqName, source.treeStructure, names) { fqName, name ->`
`134`		`- visitor?.visitPackage(fqName, name)`
	`134`	`+ visitor?.visitPackage(fqName, name, context)`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`}`
`@@ -152,13 +152,13 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`152`	`152`	`fqName.parent(), fqName.shortName())`
`153`	`153`
`154`	`154`	`if (klass != null) {`
`155`		`- visitor?.visitClassReference(klass, name)`
	`155`	`+ visitor?.visitClassReference(klass, name, context)`
`156`	`156`	`} else if (callables.isNotEmpty()) {`
`157`	`157`	`for (callable in callables) {`
`158`		`- visitor?.visitCallableReference(callable, name)`
	`158`	`+ visitor?.visitCallableReference(callable, name, context)`
`159`	`159`	`}`
`160`	`160`	`} else {`
`161`		`- visitor?.visitPackage(fqName, name)`
	`161`	`+ visitor?.visitPackage(fqName, name, context)`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`	`}`
`@@ -176,7 +176,15 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`176`	`176`	`val source = declaration.source ?: return`
`177`	`177`	`val ktFile = context.containingFile?.sourceFile ?: return`
`178`	`178`	`val visitor = visitors[ktFile]`
`179`		`- visitor?.visitClassOrObject(declaration, getIdentifier(source))`
	`179`	`+ visitor?.visitClassOrObject(declaration, getIdentifier(source), context)`
	`180`	`+`
	`181`	`+ for (superType in declaration.superTypeRefs) {`
	`182`	`+ val superSymbol = superType.toClassLikeSymbol(context.session)`
	`183`	`+ val superSource = superType.source`
	`184`	`+ if (superSymbol != null && superSource != null) {`
	`185`	`+ visitor?.visitClassReference(superSymbol, superSource, context)`
	`186`	`+ }`
	`187`	`+ }`
`180`	`188`	`}`
`181`	`189`	`}`
`182`	`190`
`@@ -202,9 +210,9 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`202`	`210`	`.findChildByType(source.lighterASTNode, KtTokens.CONSTRUCTOR_KEYWORD)`
`203`	`211`	`?.toKtLightSourceElement(source.treeStructure)`
`204`	`212`
`205`		`- visitor?.visitPrimaryConstructor(declaration, constructorKeyboard ?: getIdentifier(klassSource))`
	`213`	`+ visitor?.visitPrimaryConstructor(declaration, constructorKeyboard ?: getIdentifier(klassSource), context)`
`206`	`214`	`} else {`
`207`		`- visitor?.visitSecondaryConstructor(declaration, getIdentifier(source))`
	`215`	`+ visitor?.visitSecondaryConstructor(declaration, getIdentifier(source), context)`
`208`	`216`	`}`
`209`	`217`	`}`
`210`	`218`	`}`
`@@ -219,7 +227,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`219`	`227`	`val source = declaration.source ?: return`
`220`	`228`	`val ktFile = context.containingFile?.sourceFile ?: return`
`221`	`229`	`val visitor = visitors[ktFile]`
`222`		`- visitor?.visitNamedFunction(declaration, getIdentifier(source))`
	`230`	`+ visitor?.visitNamedFunction(declaration, getIdentifier(source), context)`
`223`	`231`	`}`
`224`	`232`	`}`
`225`	`233`
`@@ -234,7 +242,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`234`	`242`	`val source = declaration.source ?: return`
`235`	`243`	`val ktFile = context.containingFile?.sourceFile ?: return`
`236`	`244`	`val visitor = visitors[ktFile]`
`237`		`- visitor?.visitNamedFunction(declaration, source)`
	`245`	`+ visitor?.visitNamedFunction(declaration, source, context)`
`238`	`246`	`}`
`239`	`247`	`}`
`240`	`248`
`@@ -248,12 +256,12 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`248`	`256`	`val source = declaration.source ?: return`
`249`	`257`	`val ktFile = context.containingFile?.sourceFile ?: return`
`250`	`258`	`val visitor = visitors[ktFile]`
`251`		`- visitor?.visitProperty(declaration, getIdentifier(source))`
	`259`	`+ visitor?.visitProperty(declaration, getIdentifier(source), context)`
`252`	`260`
`253`	`261`	`val klass = declaration.returnTypeRef.toClassLikeSymbol(context.session)`
`254`	`262`	`val klassSource = declaration.returnTypeRef.source`
`255`	`263`	`if (klass != null && klassSource != null) {`
`256`		`- visitor?.visitClassReference(klass, getIdentifier(klassSource))`
	`264`	`+ visitor?.visitClassReference(klass, getIdentifier(klassSource), context)`
`257`	`265`	`}`
`258`	`266`	`}`
`259`	`267`	`}`
`@@ -268,7 +276,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`268`	`276`	`val source = declaration.source ?: return`
`269`	`277`	`val ktFile = context.containingFile?.sourceFile ?: return`
`270`	`278`	`val visitor = visitors[ktFile]`
`271`		`- visitor?.visitParameter(declaration, getIdentifier(source))`
	`279`	`+ visitor?.visitParameter(declaration, getIdentifier(source), context)`
`272`	`280`	`}`
`273`	`281`	`}`
`274`	`282`
`@@ -282,7 +290,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`282`	`290`	`val source = declaration.source ?: return`
`283`	`291`	`val ktFile = context.containingFile?.sourceFile ?: return`
`284`	`292`	`val visitor = visitors[ktFile]`
`285`		`- visitor?.visitTypeParameter(declaration, getIdentifier(source))`
	`293`	`+ visitor?.visitTypeParameter(declaration, getIdentifier(source), context)`
`286`	`294`	`}`
`287`	`295`	`}`
`288`	`296`
`@@ -296,7 +304,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`296`	`304`	`val source = declaration.source ?: return`
`297`	`305`	`val ktFile = context.containingFile?.sourceFile ?: return`
`298`	`306`	`val visitor = visitors[ktFile]`
`299`		`- visitor?.visitTypeAlias(declaration, getIdentifier(source))`
	`307`	`+ visitor?.visitTypeAlias(declaration, getIdentifier(source), context)`
`300`	`308`	`}`
`301`	`309`	`}`
`302`	`310`
`@@ -328,7 +336,7 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`328`	`336`	`getIdentifier(source)`
`329`	`337`	`}`
`330`	`338`
`331`		`- visitor?.visitPropertyAccessor(declaration, identifierSource)`
	`339`	`+ visitor?.visitPropertyAccessor(declaration, identifierSource, context)`
`332`	`340`	`}`
`333`	`341`	`}`
`334`	`342`
`@@ -348,23 +356,23 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio`
`348`	`356`
`349`	`357`	`val ktFile = context.containingFile?.sourceFile ?: return`
`350`	`358`	`val visitor = visitors[ktFile]`
`351`		`- visitor?.visitSimpleNameExpression(calleeReference, getIdentifier(calleeReference.source ?: source))`
	`359`	`+ visitor?.visitSimpleNameExpression(calleeReference, getIdentifier(calleeReference.source ?: source), context)`
`352`	`360`
`353`	`361`	`val resolvedSymbol = calleeReference.resolvedSymbol`
`354`	`362`	`if (resolvedSymbol.origin == FirDeclarationOrigin.SamConstructor && resolvedSymbol is FirSyntheticFunctionSymbol) {`
`355`	`363`	`val referencedKlass = resolvedSymbol.resolvedReturnType.toClassLikeSymbol(context.session)`
`356`	`364`	`if (referencedKlass != null) {`
`357`		`- visitor?.visitClassReference(referencedKlass, getIdentifier(calleeReference.source ?: source))`
	`365`	`+ visitor?.visitClassReference(referencedKlass, getIdentifier(calleeReference.source ?: source), context)`
`358`	`366`	`}`
`359`	`367`	`}`
`360`	`368`
`361`	`369`	`// When encountering a reference to a property symbol, emit both getter and setter symbols`
`362`	`370`	`if (resolvedSymbol is FirPropertySymbol) {`
`363`	`371`	`resolvedSymbol.getterSymbol?.let {`
`364`		`- visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source))`
	`372`	`+ visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source), context)`
`365`	`373`	`}`
`366`	`374`	`resolvedSymbol.setterSymbol?.let {`
`367`		`- visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source))`
	`375`	`+ visitor?.visitCallableReference(it, getIdentifier(calleeReference.source ?: source), context)`
`368`	`376`	`}`
`369`	`377`	`}`
`370`	`378`	`}`