Package and import support

nicolas-guichard · antonsviridov-src · commit 01db07aec307 · 2025-06-30T15:33:53.000+01:00
We need to support the package directive and the imports so that:
- `package a.b.c` has 3 symbol occurences, for `a/`, `a/b/` and `a/b/c/`
- `import a.b.Klass` has 3 symbol occurences, for `a/`, `a/b/` and
  `a/b/Klass#`

Still 5 failing tests.
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
@@ -2,10 +2,13 @@ package com.sourcegraph.semanticdb_kotlinc
 
 import java.nio.file.Path
 import kotlin.contracts.ExperimentalContracts
-import org.jetbrains.kotlin.KtSourceElement
-import org.jetbrains.kotlin.KtSourceFile
+import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.com.intellij.lang.LighterASTNode
+import org.jetbrains.kotlin.com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.collectDescendantsOfType
 import org.jetbrains.kotlin.diagnostics.findChildByType
+import org.jetbrains.kotlin.diagnostics.findLastDescendant
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
@@ -20,7 +23,7 @@ import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.toKtLightSourceElement
+import org.jetbrains.kotlin.name.FqName
 
 open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtension(session) {
     companion object {
@@ -92,15 +95,69 @@ open class AnalyzerCheckers(session: FirSession) : FirAdditionalCheckersExtensio
             reporter: DiagnosticReporter
         ) {
             val ktFile = declaration.sourceFile ?: return
+            val visitor = visitors[ktFile]
+
+            val eachFqNameElement =
+                {
+                fqName: FqName,
+                tree: FlyweightCapableTreeStructure<LighterASTNode>,
+                names: LighterASTNode,
+                callback: (FqName, KtLightSourceElement) -> Unit ->
+                val nameList =
+                    if (names.tokenType == KtNodeTypes.REFERENCE_EXPRESSION) listOf(names)
+                    else tree.collectDescendantsOfType(names, KtNodeTypes.REFERENCE_EXPRESSION)
+
+                var ancestor = fqName
+                var depth = 0
+                while (ancestor != FqName.ROOT) {
+                    val nameNode = nameList[nameList.lastIndex - depth]
+                    val nameSource = nameNode.toKtLightSourceElement(tree)
+
+                    callback(ancestor, nameSource)
+
+                    ancestor = ancestor.parent()
+                    depth++
+                }
+            }
+
+            val packageDirective = declaration.packageDirective
+            val fqName = packageDirective.packageFqName
+            val source = packageDirective.source
+            if (source != null) {
+                val names = source.treeStructure.findLastDescendant(source.lighterASTNode) { true }
+                if (names != null) {
+                    eachFqNameElement(fqName, source.treeStructure, names) { fqName, name ->
+                        visitor?.visitPackage(fqName, name)
+                    }
+                }
+            }
+
             declaration.imports.forEach { import ->
                 val source = import.source ?: return@forEach
-                val visitor = visitors[ktFile]
                 val fqName = import.importedFqName ?: return@forEach
-                val importedClassSymbol =
-                    context.session.symbolProvider.getClassLikeSymbolByClassId(
-                        ClassId.topLevel(fqName))
-                        ?: return@forEach
-                visitor?.visitImport(importedClassSymbol, source)
+
+                val names = source.treeStructure.findLastDescendant(source.lighterASTNode) { true }
+                if (names != null) {
+                    eachFqNameElement(fqName, source.treeStructure, names) { fqName, name ->
+                        val symbolProvider = context.session.symbolProvider
+
+                        val klass =
+                            symbolProvider.getClassLikeSymbolByClassId(ClassId.topLevel(fqName))
+                        val callables =
+                            symbolProvider.getTopLevelCallableSymbols(
+                                fqName.parent(), fqName.shortName())
+
+                        if (klass != null) {
+                            visitor?.visitClassReference(klass, name)
+                        } else if (callables.isNotEmpty()) {
+                            for (callable in callables) {
+                                visitor?.visitCallableReference(callable, name)
+                            }
+                        } else {
+                            visitor?.visitPackage(fqName, name)
+                        }
+                    }
+                }
             }
         }
     }
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
@@ -42,7 +42,7 @@ class SemanticdbTextDocumentBuilder(
     }
 
     fun emitSemanticdbData(
-        firBasedSymbol: FirBasedSymbol<*>,
+        firBasedSymbol: FirBasedSymbol<*>?,
         symbol: Symbol,
         element: KtSourceElement,
         role: Role
@@ -62,7 +62,7 @@ class SemanticdbTextDocumentBuilder(
 
     @OptIn(SymbolInternals::class)
     private fun symbolInformation(
-        firBasedSymbol: FirBasedSymbol<*>,
+        firBasedSymbol: FirBasedSymbol<*>?,
         symbol: Symbol,
         element: KtSourceElement
     ): Semanticdb.SymbolInformation {
@@ -81,8 +81,21 @@ class SemanticdbTextDocumentBuilder(
             }
         return SymbolInformation {
             this.symbol = symbol.toString()
-            this.displayName = displayName(firBasedSymbol)
-            this.documentation = semanticdbDocumentation(firBasedSymbol.fir)
+            this.displayName =
+                if (firBasedSymbol != null) {
+                    displayName(firBasedSymbol)
+                } else {
+                    element.text.toString()
+                }
+            this.documentation =
+                if (firBasedSymbol != null) {
+                    semanticdbDocumentation(firBasedSymbol.fir)
+                } else {
+                    Documentation {
+                        format = Semanticdb.Documentation.Format.MARKDOWN
+                        message = ""
+                    }
+                }
             this.addAllOverriddenSymbols(supers)
             this.language =
                 when (element.psi?.language ?: KotlinLanguage.INSTANCE) {
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
@@ -8,7 +8,9 @@ import org.jetbrains.kotlin.KtSourceFile
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+import org.jetbrains.kotlin.name.FqName
 
 @ExperimentalContracts
 class SemanticdbVisitor(
@@ -22,7 +24,7 @@ class SemanticdbVisitor(
     private val documentBuilder = SemanticdbTextDocumentBuilder(sourceroot, file, lineMap)
 
     private data class SymbolDescriptorPair(
-        val firBasedSymbol: FirBasedSymbol<*>,
+        val firBasedSymbol: FirBasedSymbol<*>?,
         val symbol: Symbol
     )
 
@@ -40,10 +42,18 @@ class SemanticdbVisitor(
             ?.map { it.symbol }
             ?.toList()
 
-    private fun Sequence<Symbol>.with(firBasedSymbol: FirBasedSymbol<*>) =
+    private fun Sequence<Symbol>.with(firBasedSymbol: FirBasedSymbol<*>?) =
         this.map { SymbolDescriptorPair(firBasedSymbol, it) }
 
-    fun visitImport(firClassSymbol: FirClassLikeSymbol<*>, element: KtSourceElement) {
+    fun visitPackage(pkg: FqName, element: KtSourceElement) {
+        cache[pkg].with(null).emitAll(element, Role.REFERENCE)
+    }
+
+    fun visitClassReference(firClassSymbol: FirClassLikeSymbol<*>, element: KtSourceElement) {
+        cache[firClassSymbol].with(firClassSymbol).emitAll(element, Role.REFERENCE)
+    }
+
+    fun visitCallableReference(firClassSymbol: FirCallableSymbol<*>, element: KtSourceElement) {
         cache[firClassSymbol].with(firClassSymbol).emitAll(element, Role.REFERENCE)
     }
 
diff --git a/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SymbolsCache.kt b/semanticdb-kotlinc/src/main/kotlin/com/sourcegraph/semanticdb_kotlinc/SymbolsCache.kt
@@ -31,6 +31,8 @@ class GlobalSymbolsCache(testing: Boolean = false) : Iterable<Symbol> {
         emitSymbols(symbol, locals)
     }
 
+    operator fun get(symbol: FqName): Sequence<Symbol> = sequence { emitSymbols(symbol) }
+
     /**
      * called whenever a new symbol should be yielded in the sequence e.g. for properties we also
      * want to yield for every implicit getter/setter, but wouldn't want to yield for e.g. the
@@ -50,6 +52,10 @@ class GlobalSymbolsCache(testing: Boolean = false) : Iterable<Symbol> {
         }
     }
 
+    private suspend fun SequenceScope<Symbol>.emitSymbols(symbol: FqName) {
+        yield(getSymbol(symbol))
+    }
+
     /**
      * Entrypoint for building or looking-up a symbol without yielding a value in the sequence.
      * Called recursively for every part of a symbol, unless a cached result short circuits.
@@ -220,4 +226,5 @@ class LocalSymbolsCache : Iterable<Symbol> {
 @ExperimentalContracts
 class SymbolsCache(private val globals: GlobalSymbolsCache, private val locals: LocalSymbolsCache) {
     operator fun get(symbol: FirBasedSymbol<*>) = globals[symbol, locals]
+    operator fun get(symbol: FqName) = globals[symbol]
 }

Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,8 @@ class GlobalSymbolsCache(testing: Boolean = false) : Iterable<Symbol> {`
`31`	`31`	`emitSymbols(symbol, locals)`
`32`	`32`	`}`
`33`	`33`
	`34`	`+ operator fun get(symbol: FqName): Sequence<Symbol> = sequence { emitSymbols(symbol) }`
	`35`	`+`
`34`	`36`	`/**`
`35`	`37`	`* called whenever a new symbol should be yielded in the sequence e.g. for properties we also`
`36`	`38`	`* want to yield for every implicit getter/setter, but wouldn't want to yield for e.g. the`
`@@ -50,6 +52,10 @@ class GlobalSymbolsCache(testing: Boolean = false) : Iterable<Symbol> {`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`
	`55`	`+ private suspend fun SequenceScope<Symbol>.emitSymbols(symbol: FqName) {`
	`56`	`+ yield(getSymbol(symbol))`
	`57`	`+ }`
	`58`	`+`
`53`	`59`	`/**`
`54`	`60`	`* Entrypoint for building or looking-up a symbol without yielding a value in the sequence.`
`55`	`61`	`* Called recursively for every part of a symbol, unless a cached result short circuits.`
`@@ -220,4 +226,5 @@ class LocalSymbolsCache : Iterable<Symbol> {`
`220`	`226`	`@ExperimentalContracts`
`221`	`227`	`class SymbolsCache(private val globals: GlobalSymbolsCache, private val locals: LocalSymbolsCache) {`
`222`	`228`	`operator fun get(symbol: FirBasedSymbol<*>) = globals[symbol, locals]`
	`229`	`+ operator fun get(symbol: FqName) = globals[symbol]`
`223`	`230`	`}`