refactor(java): extract type resolution logic into separate function #257

Move recursive type resolution logic from `resolveByType` to a new private function `resolveTypeReferences` for better readability and maintainability

Author: phodal

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

@@ -51,20 +51,20 @@ enum class BuiltinCommand(
         true
     ),
     DIR("dir", "List files and directories in a tree-like structure", AllIcons.Actions.ProjectDirectory, true, true),
-    LOCAL_SEARCH(
-        "localSearch",
-        "Search text in the project will return 5 line before and after",
-        AllIcons.Actions.Search,
-        true,
-        true
-    ),
     DATABASE(
         "database",
         "Read the content of a database, /database:query\n```sql\nSELECT * FROM table\n```",
         AllIcons.Toolwindows.ToolWindowHierarchy,
         true,
         true
     ),
+    LOCAL_SEARCH(
+        "localSearch",
+        "Search text in the project will return 5 line before and after",
+        AllIcons.Actions.Search,
+        true,
+        true
+    ),
     RELATED(
         "related",
         "Get related content by the current file",

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

@@ -10,33 +10,31 @@ object JavaTypeUtil {
     fun resolveByType(outputType: PsiType?): Map<String, PsiClass> {
         val resolvedClasses = mutableMapOf<String, PsiClass>()
         if (outputType is PsiClassReferenceType) {
-            val resolveClz = outputType.resolve()
-
-            outputType.parameters.filterIsInstance<PsiClassReferenceType>().forEach {
-                val resolve = it.resolve()
-                if (resolve != null) {
-                    resolvedClasses[it.canonicalText] = resolve
-                }
-
-                it.parameters.map { argType ->
-                    if (argType is PsiClassReferenceType) {
-                        val resolvedArgType = argType.resolve()
-                        if (resolvedArgType != null) {
-                            resolvedClasses[argType.canonicalText] = resolvedArgType
-                        }
-                    }
-                }
+            resolvedClasses.putAll(resolveTypeReferences(outputType))
+        }
+
+        return resolvedClasses.filter { isProjectContent(it.value) }.toMap()
+    }
+
+    private fun resolveTypeReferences(outputType: PsiClassReferenceType): MutableMap<String, PsiClass> {
+        val resolvedClasses = mutableMapOf<String, PsiClass>()
+
+        fun resolveRecursively(type: PsiClassReferenceType) {
+            val resolvedClass = type.resolve()
+            if (resolvedClass != null) {
+                resolvedClasses[type.canonicalText] = resolvedClass
             }
 
-            val canonicalText = outputType.canonicalText
-            if (resolveClz != null) {
-                resolvedClasses[canonicalText] = resolveClz
+            type.parameters.filterIsInstance<PsiClassReferenceType>().forEach { childType ->
+                resolveRecursively(childType)
             }
         }
 
-        return resolvedClasses.filter { isProjectContent(it.value) }.toMap()
+        resolveRecursively(outputType)
+        return resolvedClasses
     }
 
+
     fun resolveByField(element: PsiElement): Map<String, PsiClass> {
         val psiFile = element.containingFile as PsiJavaFile