feat: try to handle for basic class issues

Author: phodal

java/src/main/kotlin/cc/unitmesh/idea/DtModelExt.kt

@@ -16,6 +16,9 @@ fun fromJavaFile(file: PsiJavaFileImpl?): DtClass {
     }
 }
 
+private val classCache = mutableMapOf<String, DtClass>()
+
+
 fun DtClass.Companion.formatPsi(psiClass: PsiClass): String {
     return fromPsi(psiClass).commentFormat()
 }
@@ -24,39 +27,46 @@ fun DtClass.Companion.fromJavaFile(file: PsiFile): DtClass {
     return fromJavaFile(file as? PsiJavaFileImpl)
 }
 
-fun DtClass.Companion.fromPsi(psiClass: PsiClass): DtClass {
-    return runReadAction {
-        val fields = psiClass.fields.map { field ->
-            DtField(
-                name = field.name,
-                type = field.type.canonicalText
-            )
-        }
+fun DtClass.Companion.fromPsi(originClass: PsiClass): DtClass {
+    classCache[originClass.qualifiedName ?: ""]?.let {
+        return it
+    }
 
-        val methods = psiClass.methods.map { method ->
-            // if method is getter or setter, skip
-            if (method.name.startsWith("get") || method.name.startsWith("set")) {
-                return@map null
-            }
+    val psiClass = runReadAction { originClass.copy() as PsiClass }
 
-            DtMethod(
-                name = method.name,
-                returnType = method.returnType?.presentableText ?: "",
-                parameters = method.parameters.map { parameter ->
-                    DtParameter(
-                        name = parameter.name ?: "",
-                        type = parameter.type.toString().replace("PsiType:", "")
-                    )
-                }
-            )
-        }.filterNotNull()
-
-        return@runReadAction DtClass(
-            packageName = psiClass.qualifiedName ?: "",
-            path = psiClass.containingFile?.virtualFile?.path ?: "",
-            name = psiClass.name ?: "",
-            methods = methods,
-            fields = fields
+    val fields = psiClass.fields.map { field ->
+        DtField(
+            name = field.name,
+            type = field.type.toString().replace("PsiType:", "")
         )
     }
+
+    val methods = psiClass.methods.map { method ->
+        // if method is getter or setter, skip
+        if (method.name.startsWith("get") || method.name.startsWith("set")) {
+            return@map null
+        }
+
+        DtMethod(
+            name = method.name,
+            returnType = method.returnType?.presentableText ?: "",
+            parameters = method.parameters.map { parameter ->
+                DtParameter(
+                    name = parameter.name ?: "",
+                    type = parameter.type.toString().replace("PsiType:", "")
+                )
+            }
+        )
+    }.filterNotNull()
+
+    val dtClass = DtClass(
+        packageName = psiClass.qualifiedName ?: "",
+        path = psiClass.containingFile?.virtualFile?.path ?: "",
+        name = psiClass.name ?: "",
+        methods = methods,
+        fields = fields
+    )
+
+    classCache[psiClass.qualifiedName ?: ""] = dtClass
+    return dtClass
 }

java/src/main/kotlin/cc/unitmesh/idea/flow/MvcContextService.kt

@@ -32,13 +32,17 @@ class MvcContextService(private val project: Project) {
         }
     }
 
-    private fun filterImportByRegex(allImportStatements: Array<out PsiImportStatementBase>?, regex: Regex) =
-        allImportStatements?.filter {
+    private val importCache = mutableMapOf<String, List<PsiClass>>()
+    private fun filterImportByRegex(allImportStatements: Array<out PsiImportStatementBase>?, regex: Regex): List<PsiClass> {
+        return allImportStatements?.filter {
             it.importReference?.text?.lowercase()?.matches(regex) ?: false
         }?.mapNotNull {
             val importText = it.importReference?.text ?: return@mapNotNull null
-            javaPsiFacade.findClass(importText, searchScope)
-        } ?: emptyList()
+            importCache.getOrPut(importText) {
+                javaPsiFacade.findClasses(importText, searchScope).toList()
+            }
+        }?.flatten() ?: emptyList()
+    }
 
     fun servicePrompt(psiFile: PsiFile?): String {
         val file = psiFile as? PsiJavaFileImpl
@@ -63,8 +67,8 @@ ${relevantModel?.joinToString("\n")}
     fun controllerPrompt(psiFile: PsiFile?): String {
         val file = psiFile as? PsiJavaFileImpl
         val context = prepareControllerContext(file)
-        val services = context?.services?.map(DtClass.Companion::formatPsi)
-        val models = context?.models?.map(DtClass.Companion::formatPsi)
+        val services = context?.services?.distinctBy { it.qualifiedName }?.map(DtClass.Companion::formatPsi)
+        val models = context?.models?.distinctBy { it.qualifiedName }?.map(DtClass.Companion::formatPsi)
 
         val relevantModel = (services ?: emptyList()) + (models ?: emptyList())
 

src/main/kotlin/cc/unitmesh/devti/context/model/DtClass.kt

@@ -38,7 +38,10 @@ class DtClass(
         var getterSetter: List<String> = listOf()
         val methodsWithoutGetterSetter = methods
             .filter { method ->
-                val isGetter = method.name.startsWith("get") && method.parameters.isEmpty()
+                val isGetter = method.name.startsWith("get")
+                        && method.parameters.isEmpty()
+                        && !(method.name.contains("By") || method.name.contains("With") || method.name.contains("And"))
+
                 val isSetter = method.name.startsWith("set") && method.parameters.size == 1
                 if (isGetter || isSetter) {
                     getterSetter = listOf(method.name)