Changed code completion to partial match search

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/common/psi/PsiParentClass.kt

@@ -49,7 +49,7 @@ class PsiParentClass(
 
     fun searchField(fieldName: String): List<PsiField>? =
         fields?.filter { f ->
-            f.name.startsWith(fieldName) &&
+            f.name.contains(fieldName) &&
                 PropertyModifyUtil.filterPrivateField(f, type)
         }
 
@@ -80,7 +80,7 @@ class PsiParentClass(
         fields
             ?.filter { f ->
                 f.hasModifierProperty(PsiModifier.STATIC) &&
-                    f.name.startsWith(fieldName) &&
+                    f.name.contains(fieldName) &&
                     PropertyModifyUtil.filterPrivateField(f, type)
             }
 

src/main/kotlin/org/domaframework/doma/intellij/common/sql/PsiClassTypeUtil.kt

@@ -24,9 +24,11 @@ class PsiClassTypeUtil {
     companion object {
         fun getPsiTypeByList(
             classType: PsiClassType,
+            project: Project,
             useListParam: Boolean,
         ): PsiType? {
-            if (classType.className == "List" && useListParam) {
+            val isIterableType = isIterableType(classType, project)
+            if (isIterableType && useListParam) {
                 return classType.parameters.firstOrNull()
             }
             return classType

src/main/kotlin/org/domaframework/doma/intellij/common/sql/directive/EmbeddedDirectiveHandler.kt

@@ -21,6 +21,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiMethod
 import org.domaframework.doma.intellij.common.dao.findDaoMethod
+import org.domaframework.doma.intellij.extension.psi.searchParameter
 
 class EmbeddedDirectiveHandler(
     private val originalFile: PsiFile,
@@ -36,11 +37,8 @@ class EmbeddedDirectiveHandler(
             result,
         ) { daoMethod, bind ->
             daoMethod
-                ?.parameterList
-                ?.parameters
-                ?.filter {
-                    it.name.startsWith(bind)
-                }?.map { param -> VariableLookupItem(param) }
+                ?.searchParameter(bind)
+                ?.map { param -> VariableLookupItem(param) }
                 ?.toList()
                 ?: emptyList()
         }

src/main/kotlin/org/domaframework/doma/intellij/common/sql/directive/LiteralDirectiveHandler.kt

@@ -22,6 +22,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiMethod
 import org.domaframework.doma.intellij.common.dao.findDaoMethod
 import org.domaframework.doma.intellij.common.psi.PsiTypeChecker
+import org.domaframework.doma.intellij.extension.psi.searchParameter
 
 class LiteralDirectiveHandler(
     private val originalFile: PsiFile,
@@ -37,11 +38,9 @@ class LiteralDirectiveHandler(
             result,
         ) { daoMethod, bind ->
             daoMethod
-                ?.parameterList
-                ?.parameters
+                ?.searchParameter(bind)
                 ?.filter {
-                    it.name.startsWith(bind) &&
-                        PsiTypeChecker.isTargetType(it.type)
+                    PsiTypeChecker.isTargetType(it.type)
                 }?.map { param -> VariableLookupItem(param) }
                 ?.toList()
                 ?: emptyList()

src/main/kotlin/org/domaframework/doma/intellij/common/sql/directive/PercentDirectiveHandler.kt

@@ -48,7 +48,7 @@ class PercentDirectiveHandler(
                 "for",
                 "!",
             ).filter {
-                it.startsWith(bind)
+                it.contains(bind)
             }.map {
                 LookupElementBuilder
                     .create(it)

src/main/kotlin/org/domaframework/doma/intellij/common/sql/validator/SqlElChildElementValidator.kt

@@ -15,6 +15,7 @@
  */
 package org.domaframework.doma.intellij.common.sql.validator
 
+import com.intellij.psi.PsiClassType
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiType
 import com.intellij.psi.util.elementType
@@ -24,15 +25,13 @@ import org.domaframework.doma.intellij.common.sql.cleanString
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationCompleteResult
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationPropertyResult
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationResult
-import org.domaframework.doma.intellij.extension.psi.getMethodReturnType
-import org.domaframework.doma.intellij.extension.psi.getParameterType
 import org.domaframework.doma.intellij.psi.SqlElIdExpr
 import org.domaframework.doma.intellij.psi.SqlElParameters
 import org.domaframework.doma.intellij.psi.SqlTypes
 
 abstract class SqlElChildElementValidator(
     open val blocks: List<PsiElement>,
-    open val shorName: String,
+    open val shorName: String = "",
 ) {
     abstract fun validateChildren(dropIndex: Int = 0): ValidationResult?
 
@@ -61,7 +60,12 @@ abstract class SqlElChildElementValidator(
         findFieldMethod: ((PsiType) -> PsiParentClass)? = { type -> PsiParentClass(type) },
         complete: ((PsiParentClass) -> Unit) = { parent: PsiParentClass? -> },
     ): ValidationResult? {
+        val project = blocks.firstOrNull()?.project ?: return null
+
         var parent = topParent
+        val parentType = parent.type
+        val classType = parentType as? PsiClassType ?: return null
+
         var competeResult: ValidationCompleteResult? = null
 
         if (dropLastIndex > 0 && blocks.drop(1).dropLast(dropLastIndex).isEmpty()) {
@@ -71,9 +75,9 @@ abstract class SqlElChildElementValidator(
             )
         }
 
-        var getMethodReturnType: PsiType? =
-            if (PsiClassTypeUtil.isCollect(topParent.type)) {
-                topParent.type
+        var parentListBaseType: PsiType? =
+            if (PsiClassTypeUtil.isIterableType(classType, project)) {
+                parentType
             } else {
                 null
             }
@@ -90,28 +94,41 @@ abstract class SqlElChildElementValidator(
 
             val field =
                 parent
-                    .findField(element.text)
+                    .findField(searchElm)
                     ?.let { match ->
-                        val type = match.type
-                        val methodReturnType =
-                            getMethodReturnType?.let { match.getParameterType(it, type, listParamIndex) }
-                                ?: type
-                        if (PsiClassTypeUtil.isCollect(type)) {
-                            getMethodReturnType = type
+                        val type =
+                            parentListBaseType?.let { PsiClassTypeUtil.getParameterType(project, match.type, it, listParamIndex) }
+                                ?: match.type
+                        val classType = type as? PsiClassType
+                        if (classType != null && PsiClassTypeUtil.isIterableType(classType, element.project)) {
+                            parentListBaseType = type
                             listParamIndex = 0
                         }
-                        findFieldMethod?.invoke(methodReturnType)
+                        findFieldMethod?.invoke(type)
                     }
             val method =
                 parent
-                    .findMethod(element.text)
+                    .findMethod(searchElm)
                     ?.let { match ->
                         val returnType = match.returnType ?: return null
                         val methodReturnType =
-                            getMethodReturnType?.let { match.getMethodReturnType(it, listParamIndex) }
+                            parentListBaseType?.let {
+                                PsiClassTypeUtil.getParameterType(
+                                    project,
+                                    returnType,
+                                    it,
+                                    listParamIndex,
+                                )
+                            }
                                 ?: returnType
-                        if (PsiClassTypeUtil.isCollect(returnType)) {
-                            getMethodReturnType = returnType
+                        val classType = methodReturnType as? PsiClassType
+                        if (classType != null &&
+                            PsiClassTypeUtil.isIterableType(
+                                classType,
+                                element.project,
+                            )
+                        ) {
+                            parentListBaseType = methodReturnType
                             listParamIndex = 0
                         }
                         findFieldMethod?.invoke(methodReturnType)

src/main/kotlin/org/domaframework/doma/intellij/common/sql/validator/SqlElStaticFieldAccessorChildElementValidator.kt

@@ -18,33 +18,33 @@ package org.domaframework.doma.intellij.common.sql.validator
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiType
 import org.domaframework.doma.intellij.common.psi.PsiParentClass
+import org.domaframework.doma.intellij.common.psi.PsiStaticElement
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationCompleteResult
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationIgnoreResult
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationPropertyResult
 import org.domaframework.doma.intellij.common.sql.validator.result.ValidationResult
 import org.domaframework.doma.intellij.extension.expr.fqdn
-import org.domaframework.doma.intellij.extension.getJavaClazz
 import org.domaframework.doma.intellij.extension.psi.psiClassType
 import org.domaframework.doma.intellij.psi.SqlElParameters
 import org.domaframework.doma.intellij.psi.SqlElStaticFieldAccessExpr
-import org.jetbrains.kotlin.idea.base.util.module
 
 class SqlElStaticFieldAccessorChildElementValidator(
     override val blocks: List<PsiElement>,
     private val staticAccuser: SqlElStaticFieldAccessExpr,
-    override val shorName: String,
+    override val shorName: String = "",
 ) : SqlElChildElementValidator(blocks, shorName) {
     override fun validateChildren(
         dropIndex: Int,
         findFieldMethod: (PsiType) -> PsiParentClass,
         complete: (PsiParentClass) -> Unit,
     ): ValidationResult? {
-        val errorElement = getParent()
+        val errorElement = getFieldTopParent()
         when (errorElement) {
             is ValidationCompleteResult -> {
                 val parent = errorElement.parentClass
                 return validateFieldAccess(
                     parent,
+                    dropLastIndex = dropIndex,
                     complete = complete,
                 )
             }
@@ -54,28 +54,34 @@ class SqlElStaticFieldAccessorChildElementValidator(
     }
 
     override fun validateChildren(dropIndex: Int): ValidationResult? {
-        val getParentResult = getParent()
+        val getParentResult = getFieldTopParent()
         when (getParentResult) {
             is ValidationCompleteResult -> {
+                if (blocks.size == 1) {
+                    return getParentResult
+                }
                 val parent = getParentResult.parentClass
-                return validateFieldAccess(parent)
+                return validateFieldAccess(parent, dropLastIndex = dropIndex)
             }
             is ValidationIgnoreResult -> return null
             else -> return getParentResult
         }
     }
 
-    private fun getParent(): ValidationResult {
+    private fun getFieldTopParent(): ValidationResult {
         val staticTopElement =
             blocks.firstOrNull()
                 ?: return ValidationIgnoreResult(blocks.firstOrNull())
-        val module = staticAccuser.module ?: return ValidationIgnoreResult(staticTopElement)
         val fqdn = staticAccuser.fqdn
-        val clazz =
-            module.getJavaClazz(false, fqdn)
-                ?: return ValidationIgnoreResult(staticTopElement)
+        val file = staticAccuser.containingFile
+        val psiStaticElement = PsiStaticElement(fqdn, file)
+        val clazz = psiStaticElement.getRefClazz() ?: return ValidationIgnoreResult(staticTopElement)
 
         var parent = PsiParentClass(clazz.psiClassType)
+        if (blocks.size == 1) {
+            return ValidationCompleteResult(blocks.first(), parent)
+        }
+
         val nextSibling = staticTopElement.nextSibling
         val topField =
             if (nextSibling !is SqlElParameters) {

src/main/kotlin/org/domaframework/doma/intellij/extension/psi/PsiClassExtension.kt

@@ -29,7 +29,7 @@ val PsiClass.psiClassType: PsiClassType
 fun PsiClass.searchStaticField(searchName: String): Array<PsiField> =
     this.allFields
         .filter {
-            it.name.startsWith(searchName) &&
+            it.name.contains(searchName) &&
                 it.hasModifierProperty(PsiModifier.STATIC) &&
                 PropertyModifyUtil.filterPrivateField(it, this.psiClassType)
         }.toTypedArray()
@@ -44,7 +44,7 @@ fun PsiClass.findStaticField(searchName: String): PsiField? =
 fun PsiClass.searchStaticMethod(searchName: String): Array<PsiMethod> =
     this.allMethods
         .filter {
-            it.name.startsWith(searchName) &&
+            it.name.contains(searchName) &&
                 it.hasModifierProperty(PsiModifier.STATIC) &&
                 it.hasModifierProperty(PsiModifier.PUBLIC)
         }.toTypedArray()

src/main/kotlin/org/domaframework/doma/intellij/extension/psi/PsiFieldExtension.kt

@@ -16,18 +16,15 @@
 package org.domaframework.doma.intellij.extension.psi
 
 import com.intellij.codeInsight.AnnotationUtil
-import com.intellij.psi.PsiClassType
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiParameter
-import com.intellij.psi.PsiType
-import org.domaframework.doma.intellij.common.sql.PsiClassTypeUtil
 
 fun PsiMethod.findParameter(searchName: String): PsiParameter? = this.methodParameters.firstOrNull { it.name == searchName }
 
 val PsiMethod.methodParameters: List<PsiParameter>
     get() = this.parameterList.parameters.toList()
 
-fun PsiMethod.searchParameter(searchName: String): List<PsiParameter> = this.methodParameters.filter { it.name.startsWith(searchName) }
+fun PsiMethod.searchParameter(searchName: String): List<PsiParameter> = this.methodParameters.filter { it.name.contains(searchName) }
 
 @OptIn(ExperimentalStdlibApi::class)
 fun PsiMethod.getDomaAnnotationType(): DomaAnnotationType {
@@ -38,18 +35,3 @@ fun PsiMethod.getDomaAnnotationType(): DomaAnnotationType {
     }
     return DomaAnnotationType.Unknown
 }
-
-/**
- * If the type of the variable referenced from the Dao argument is List type,
- * search processing to obtain the nested type
- */
-fun PsiMethod.getMethodReturnType(
-    preReturnListType: PsiType,
-    index: Int,
-): PsiClassType? =
-    PsiClassTypeUtil.getParameterType(
-        this.project,
-        this.returnType,
-        preReturnListType,
-        index,
-    )