feat(java): add related symbol resolution and command #257

- Introduce `RelatedSymbolInsCommand` for resolving related symbols in Java.
- Enhance `JavaCustomDevInsSymbolProvider` with `resolveElement` for better symbol resolution.
- Add `RELATED` builtin command for fetching related content.
- Improve `JavaTypeUtil` to handle type resolution more robustly.

Author: phodal

core/src/main/kotlin/cc/unitmesh/devti/provider/devins/DevInsSymbolProvider.kt

@@ -5,6 +5,7 @@ import com.intellij.codeInsight.completion.CompletionResultSet
 import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.openapi.extensions.ExtensionPointName
 import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
 
 /**
  * The symbol provider for DevIns completion and execution
@@ -24,6 +25,8 @@ interface DevInsSymbolProvider {
         result: CompletionResultSet
     ): List<LookupElement>
 
+    fun resolveElement(project: Project, symbol: String): List<PsiElement>
+
     /**
      * Resolves the symbol for different programming languages.
      * For example, in Java:

…esh/devti/sketch/run/SketchRunContext.kt …nitmesh/devti/sketch/SketchRunContext.ktcore/src/main/kotlin/cc/unitmesh/devti/sketch/run/SketchRunContext.kt renamed to core/src/main/kotlin/cc/unitmesh/devti/sketch/SketchRunContext.kt core/src/main/kotlin/cc/unitmesh/devti/sketch/run/SketchRunContext.kt renamed to core/src/main/kotlin/cc/unitmesh/devti/sketch/SketchRunContext.kt

@@ -1,4 +1,4 @@
-package cc.unitmesh.devti.sketch.run
+package cc.unitmesh.devti.sketch
 
 import com.intellij.openapi.vfs.VirtualFile
 

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/DevInsCompiler.kt

@@ -253,6 +253,12 @@ class DevInsCompiler(
                 LocalSearchInsCommand(myProject, prop, shireCode)
             }
 
+
+            BuiltinCommand.RELATED -> {
+                result.isLocalCommand = true
+                RelatedSymbolInsCommand(myProject, prop)
+            }
+
             else -> {
                 PrintInsCommand("/" + commandNode.commandName + ":" + prop)
             }

…ti/language/compiler/BrowseInsCommand.kt …nguage/compiler/exec/BrowseInsCommand.ktexts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/BrowseInsCommand.kt renamed to exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/BrowseInsCommand.kt exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/BrowseInsCommand.kt renamed to exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/BrowseInsCommand.kt

@@ -1,7 +1,6 @@
-package cc.unitmesh.devti.language.compiler
+package cc.unitmesh.devti.language.compiler.exec
 
 import cc.unitmesh.devti.language.agenttool.browse.BrowseTool
-import cc.unitmesh.devti.language.compiler.exec.InsCommand
 import com.intellij.openapi.application.runInEdt
 import com.intellij.openapi.project.Project
 

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/RelatedSymbolInsCommand.kt

@@ -0,0 +1,23 @@
+package cc.unitmesh.devti.language.compiler.exec
+
+import cc.unitmesh.devti.provider.RelatedClassesProvider
+import cc.unitmesh.devti.provider.devins.DevInsSymbolProvider
+import com.intellij.openapi.project.Project
+
+class RelatedSymbolInsCommand(val myProject: Project, private val symbol: String) : InsCommand {
+    override suspend fun execute(): String? {
+        val elements = DevInsSymbolProvider.all().map {
+            it.resolveElement(myProject, symbol)
+        }.flatten()
+
+        if (elements.isEmpty()) return null
+
+        val psiElements = elements.mapNotNull {
+            RelatedClassesProvider.provide(it.language)?.lookup(it)
+        }.flatten()
+
+        if (psiElements.isEmpty()) return null
+
+        return psiElements.joinToString("\n") { it.text }
+    }
+}

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/completion/dataprovider/BuiltinCommand.kt

@@ -65,6 +65,13 @@ enum class BuiltinCommand(
         true,
         true
     ),
+    RELATED(
+        "related",
+        "Get related content by the current file",
+        AllIcons.Actions.Find,
+        true,
+        true
+    ),
     ;
 
     companion object {

exts/devins-lang/src/main/resources/agent/toolExamples/related.devin

@@ -0,0 +1 @@
+/related:cc.unitmesh.devti.language.psi

java/src/main/kotlin/cc/unitmesh/idea/provider/JavaCustomDevInsSymbolProvider.kt

@@ -7,6 +7,7 @@ import com.intellij.codeInsight.lookup.LookupElementBuilder
 import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.lang.java.JavaLanguage
 import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiPackageStatement
 import com.intellij.psi.impl.file.impl.JavaFileManagerImpl
@@ -52,7 +53,7 @@ class JavaCustomDevInsSymbolProvider : DevInsSymbolProvider {
     }
 
     override fun resolveSymbol(project: Project, symbol: String): List<String> {
-        val scope = GlobalSearchScope.allScope(project)
+        val scope = ProjectScope.getProjectScope(project)
 
         if (symbol.isEmpty()) return emptyList()
 
@@ -94,6 +95,51 @@ class JavaCustomDevInsSymbolProvider : DevInsSymbolProvider {
         return emptyList()
     }
 
+
+    override fun resolveElement(project: Project, symbol: String): List<PsiElement> {
+        val scope = ProjectScope.getProjectScope(project)
+
+        if (symbol.isEmpty()) return emptyList()
+
+        // className only, like `String` not Dot
+        if (symbol.contains(".").not()) {
+            val psiClasses = PsiShortNamesCache.getInstance(project).getClassesByName(symbol, scope)
+            if (psiClasses.isNotEmpty()) {
+                return psiClasses.toList()
+            }
+        }
+
+        // for package name only, like `cc.unitmesh`
+        JavaFileManagerImpl(project).findPackage(symbol)?.let { pkg ->
+            return pkg.classes.toList()
+        }
+
+        // for single class, with function name, like `cc.unitmesh.idea.provider.JavaCustomDevInsSymbolProvider`
+        val clazz = JavaFileManagerImpl(project).findClass(symbol, scope)
+        if (clazz != null) {
+            return listOf(clazz)
+        }
+
+        // for lookup for method
+        val split = symbol.split("#")
+        if (split.size == 2) {
+            val clazzName = split[0]
+            val methodName = split[1]
+            return lookupElementWithMethodName(project, clazzName, scope, methodName)
+        }
+
+        // may by not our format, like <package>.<class>.<method> split last
+        val lastDotIndex = symbol.lastIndexOf(".")
+        if (lastDotIndex != -1) {
+            val clazzName = symbol.substring(0, lastDotIndex)
+            val methodName = symbol.substring(lastDotIndex + 1)
+            return lookupElementWithMethodName(project, clazzName, scope, methodName)
+        }
+
+        return emptyList()
+    }
+
+
     private fun lookupWithMethodName(
         project: Project,
         clazzName: String,
@@ -110,4 +156,21 @@ class JavaCustomDevInsSymbolProvider : DevInsSymbolProvider {
 
         return emptyList()
     }
+
+    private fun lookupElementWithMethodName(
+        project: Project,
+        clazzName: String,
+        scope: GlobalSearchScope,
+        methodName: String
+    ): List<PsiElement> {
+        val psiClass = JavaFileManagerImpl(project).findClass(clazzName, scope)
+        if (psiClass != null) {
+            val psiMethod = psiClass.findMethodsByName(methodName, true).firstOrNull()
+            if (psiMethod != null) {
+                return listOf(psiMethod)
+            }
+        }
+
+        return emptyList()
+    }
 }

java/src/main/kotlin/cc/unitmesh/idea/provider/JavaRelatedClassesProvider.kt

@@ -2,6 +2,7 @@ package cc.unitmesh.idea.provider
 
 import cc.unitmesh.devti.provider.RelatedClassesProvider
 import cc.unitmesh.idea.context.JavaContextCollection
+import cc.unitmesh.idea.service.JavaTypeUtil.resolveByType
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.roots.ProjectFileIndex
@@ -16,6 +17,7 @@ class JavaRelatedClassesProvider : RelatedClassesProvider {
                 .flatMap { findSuperClasses(it) }
                 .map { cleanUp(it) }
                 .toList()
+                .distinct()
 
             is PsiClass -> findRelatedClasses(element)
             else -> emptyList()
@@ -83,13 +85,20 @@ class JavaRelatedClassesProvider : RelatedClassesProvider {
         val parameterTypes = parameters.map { it.type }
 
         val genericTypes = parameters.flatMap { (it.type as? PsiClassType)?.parameters?.toList() ?: emptyList() }
+
+        val returnType = if (method.returnTypeElement?.type != null) {
+            resolveByType(method.returnTypeElement?.type!!).values
+        } else {
+            emptyList()
+        }
+
         val mentionedTypes = parameterTypes + genericTypes
 
         val filterIsInstance = mentionedTypes.filterIsInstance<PsiClassType>()
             .distinct()
 
         return@runReadAction ApplicationManager.getApplication().executeOnPooledThread<List<PsiClass>> {
-            return@executeOnPooledThread filterIsInstance
+            return@executeOnPooledThread returnType + filterIsInstance
                 .mapNotNull { runReadAction { it.resolve() } }
                 .filter { isProjectContent(it) }
                 .toList()

java/src/main/kotlin/cc/unitmesh/idea/service/JavaTypeUtil.kt

@@ -11,9 +11,20 @@ object JavaTypeUtil {
         val resolvedClasses = mutableMapOf<String, PsiClass>()
         if (outputType is PsiClassReferenceType) {
             val resolveClz = outputType.resolve()
+
             outputType.parameters.filterIsInstance<PsiClassReferenceType>().forEach {
-                if (resolveClz != null) {
-                    resolvedClasses[it.canonicalText] = resolveClz
+                val resolve = it.resolve()
+                if (resolve != null) {
+                    resolvedClasses[it.canonicalText] = resolve
+                }
+
+                it.typeArguments().map { argType ->
+                    if (argType is PsiClassReferenceType) {
+                        val resolvedArgType = argType.resolve()
+                        if (resolvedArgType != null) {
+                            resolvedClasses[argType.canonicalText] = resolvedArgType
+                        }
+                    }
                 }
             }