[lsp] change the behavior of definition and hover requests

they should also work on the declaration itself

the change also modifies how hover works on multiresovling cases (eg, with no specific candidate) and now provides kdocs for all candidates instead of no kdoc at all

GitOrigin-RevId: a82774ed780851776d55ec7e6b829a6b98c2aec2

Author: darthorimar

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/definitions/LSDefinitionProviderCommonImpl.kt

@@ -21,6 +21,7 @@ import com.jetbrains.ls.api.features.language.LSLanguage
 import com.jetbrains.analyzer.java.JavaFilePackageIndex
 import com.jetbrains.ls.api.core.project
 import com.jetbrains.ls.api.core.withAnalysisContext
+import com.jetbrains.ls.api.features.impl.common.utils.getTargetsAtPosition
 import com.jetbrains.lsp.protocol.DefinitionParams
 import com.jetbrains.lsp.protocol.DocumentUri
 import com.jetbrains.lsp.protocol.Location
@@ -39,14 +40,9 @@ class LSDefinitionProviderCommonImpl(
                 val file = uri.findVirtualFile() ?: return@runReadAction emptyList()
                 val psiFile = file.findPsiFile(project) ?: return@runReadAction emptyList()
                 val document = file.findDocument() ?: return@runReadAction emptyList()
-                val offset = document.offsetByPosition(params.position)
-                val reference = psiFile.findReferenceAt(offset) ?: return@runReadAction emptyList()
-                val resolvedTo = when (reference) {
-                    is PsiPolyVariantReference -> reference.multiResolve(false).mapNotNull { it.element }
-                    else -> listOfNotNull(reference.resolve())
-                }
+                val targets = psiFile.getTargetsAtPosition(params.position, document)
 
-                resolvedTo.mapNotNull {
+                targets.mapNotNull {
                     when (it) {
                         is PsiPackage -> it.directory?.uri?.let { Location(DocumentUri(it), Range.BEGINNING) }
                         else -> it.getLspLocationForDefinition()

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/hover/LSHoverProviderCommonImpl.kt

@@ -1,14 +1,16 @@
 // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.jetbrains.ls.api.features.impl.common.hover
 
+import com.intellij.codeInsight.TargetElementUtilBase
 import com.intellij.lang.Language
 import com.intellij.lang.LanguageExtension
 import com.intellij.openapi.application.runReadAction
+import com.intellij.openapi.editor.Document
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.findDocument
 import com.intellij.openapi.vfs.findPsiFile
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiReference
+import com.intellij.psi.PsiFile
 import com.jetbrains.ls.api.core.util.findVirtualFile
 import com.jetbrains.ls.api.core.util.offsetByPosition
 import com.jetbrains.ls.api.core.util.toLspRange
@@ -17,10 +19,13 @@ import com.jetbrains.ls.api.core.LSServer
 import com.jetbrains.ls.api.core.project
 import com.jetbrains.ls.api.core.withAnalysisContext
 import com.jetbrains.ls.api.features.hover.LSHoverProvider
+import com.jetbrains.ls.api.features.impl.common.utils.getTargetsAtPosition
 import com.jetbrains.lsp.protocol.Hover
 import com.jetbrains.lsp.protocol.HoverParams
 import com.jetbrains.lsp.protocol.MarkupContent
 import com.jetbrains.lsp.protocol.MarkupKindType
+import com.jetbrains.lsp.protocol.Position
+import com.jetbrains.lsp.protocol.Range
 import com.jetbrains.lsp.protocol.StringOrMarkupContent
 
 abstract class AbstractLSHoverProvider : LSHoverProvider {
@@ -31,21 +36,31 @@ abstract class AbstractLSHoverProvider : LSHoverProvider {
                 val file = params.findVirtualFile() ?: return@a null
                 val psiFile = file.findPsiFile(project) ?: return@a null
                 val document = file.findDocument() ?: return@a null
-                val offset = document.offsetByPosition(params.position)
-                val reference = psiFile.findReferenceAt(offset) ?: return@a null
+                val targets = psiFile.getTargetsAtPosition(params.position, document)
+                if (targets.isEmpty()) return@a null
 
-                val markdown = generateMarkdownForElementReferencedBy(file, reference) ?: return@a null
+
+                val markdown = targets.mapNotNull {
+                    generateMarkdownForPsiElementTarget(it, psiFile)
+                }.joinToString("\n---\n")
 
                 Hover(
                     Hover.Content.Markup(MarkupContent(MarkupKindType.Markdown, markdown)),
-                    range = reference.element.textRange.toLspRange(document),
+                    range = findRange(psiFile, document, params.position),
                 )
             }
         }
     }
 
+    private fun findRange(psiFile: PsiFile, document: Document, position: Position): Range? {
+        val offset = document.offsetByPosition(position)
+        psiFile.findReferenceAt(offset)?.let { return it.element.textRange.toLspRange(document) }
+        psiFile.findElementAt(offset)?.let { return it.textRange.toLspRange(document) }
+        return null
+    }
+
     context(_: LSServer, _: LSAnalysisContext)
-    abstract fun generateMarkdownForElementReferencedBy(virtualFile: VirtualFile, reference: PsiReference): String?
+    abstract fun generateMarkdownForPsiElementTarget(target: PsiElement, from: PsiFile): String?
 
     interface LSMarkdownDocProvider {
         fun getMarkdownDoc(element: PsiElement): String?

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/references/LSReferencesProviderCommonImpl.kt

@@ -14,6 +14,7 @@ import com.jetbrains.ls.api.core.util.findVirtualFile
 import com.jetbrains.ls.api.core.util.offsetByPosition
 import com.jetbrains.ls.api.core.withAnalysisContext
 import com.jetbrains.ls.api.features.impl.common.utils.getLspLocationForDefinition
+import com.jetbrains.ls.api.features.impl.common.utils.getTargetsAtPosition
 import com.jetbrains.ls.api.features.language.LSLanguage
 import com.jetbrains.ls.api.features.references.LSReferencesProvider
 import com.jetbrains.lsp.protocol.Location
@@ -31,9 +32,7 @@ class LSReferencesProviderCommonImpl(
                 val file = params.findVirtualFile() ?: return@a
                 val psiFile = file.findPsiFile(project) ?: return@a
                 val document = file.findDocument() ?: return@a
-                val offset = document.offsetByPosition(params.position)
-                val psiSymbolService = PsiSymbolService.getInstance()
-                val targets = targetSymbols(psiFile, offset).mapNotNull { psiSymbolService.extractElementFromSymbol(it) }
+                val targets = psiFile.getTargetsAtPosition(params.position, document)
                 if (targets.isEmpty()) return@a
 
                 val findUsagesManager = FindUsagesManager(project)

features-impl/common/src/com/jetbrains/ls/api/features/impl/common/utils/targets.kt

@@ -0,0 +1,16 @@
+// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.jetbrains.ls.api.features.impl.common.utils
+
+import com.intellij.model.psi.PsiSymbolService
+import com.intellij.model.psi.impl.targetSymbols
+import com.intellij.openapi.editor.Document
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.jetbrains.ls.api.core.util.offsetByPosition
+import com.jetbrains.lsp.protocol.Position
+
+fun PsiFile.getTargetsAtPosition(position: Position, document: Document): List<PsiElement> {
+    val offset = document.offsetByPosition(position)
+    val psiSymbolService = PsiSymbolService.getInstance()
+    return targetSymbols(this, offset).mapNotNull { psiSymbolService.extractElementFromSymbol(it) }
+}

features-impl/kotlin/src/com/jetbrains/ls/api/features/impl/common/kotlin/hover/LSHoverProviderKotlinImpl.kt

@@ -1,12 +1,13 @@
 // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.jetbrains.ls.api.features.impl.common.kotlin.hover
 
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.openapi.vfs.findPsiFile
-import com.intellij.psi.PsiReference
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiMember
+import com.intellij.psi.PsiPackage
 import com.jetbrains.ls.api.core.LSAnalysisContext
 import com.jetbrains.ls.api.core.LSServer
-import com.jetbrains.ls.api.core.project
 import com.jetbrains.ls.api.features.impl.common.hover.AbstractLSHoverProvider
 import com.jetbrains.ls.api.features.impl.common.hover.markdownMultilineCode
 import com.jetbrains.ls.api.features.impl.common.kotlin.language.LSKotlinLanguage
@@ -21,19 +22,26 @@ import org.jetbrains.kotlin.analysis.api.symbols.KaConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KaDeclarationSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KaPackageSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
-import org.jetbrains.kotlin.idea.references.KtReference
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.renderer.render
 
 object LSHoverProviderKotlinImpl : AbstractLSHoverProvider() {
     override val supportedLanguages: Set<LSLanguage> get() = setOf(LSKotlinLanguage)
 
     context(_: LSServer, _: LSAnalysisContext)
-    override fun generateMarkdownForElementReferencedBy(virtualFile: VirtualFile, reference: PsiReference): String? {
-        if (reference !is KtReference) return null
-        val ktFile = virtualFile.findPsiFile(project) as? KtFile ?: return null
-        return analyze(ktFile) {
-            val symbol = reference.resolveToSymbol() ?: return null
+    override fun generateMarkdownForPsiElementTarget(target: PsiElement, from: PsiFile): String? {
+        if (from !is KtFile) return null
+
+        return analyze(from) {
+            val symbol = when (target) {
+                is KtDeclaration -> target.symbol
+                is PsiClass -> target.namedClassSymbol
+                is PsiMember -> target.callableSymbol
+                is PsiPackage -> findPackage(FqName(target.qualifiedName))
+                else -> null
+            } ?: return null
             getMarkdownContent(symbol)
         }
     }