Check Parameter Types for Method Calls in Bind Variables

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

src/main/kotlin/org/domaframework/doma/intellij/common/helper/ExpressionFunctionsHelper.kt

@@ -45,7 +45,6 @@ class ExpressionFunctionsHelper {
                         expressionClazz.superTypes.firstOrNull()?.canonicalText
                             ?: expressionClazz.psiClassType.canonicalText
                     return project?.let {
-                        expressionClazz.psiClassType.canonicalText
                         project
                             .getJavaClazz(parentType)
                             ?.isInheritor(functionInterface, true) == true

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

@@ -0,0 +1,20 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.common.psi
+
+import com.intellij.psi.PsiTypes
+
+class DummyPsiParentClass : PsiParentClass(PsiTypes.voidType())

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright Doma Tools Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.domaframework.doma.intellij.common.psi
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import org.domaframework.doma.intellij.psi.SqlElFunctionCallExpr
+import org.domaframework.doma.intellij.psi.SqlElParameters
+
+class MethodParamContext(
+    val methodIdExp: PsiElement,
+    val methodParams: SqlElParameters?,
+) {
+    companion object {
+        fun of(method: PsiElement): MethodParamContext =
+            MethodParamContext(
+                setMethodIdExp(method),
+                setParameter(method),
+            )
+
+        private fun setParameter(method: PsiElement): SqlElParameters? =
+            if (method is SqlElFunctionCallExpr) {
+                method.elParameters
+            } else {
+                PsiTreeUtil.nextLeaf(method)?.parent as? SqlElParameters
+            }
+
+        private fun setMethodIdExp(method: PsiElement): PsiElement =
+            if (method is SqlElFunctionCallExpr) {
+                method.elIdExpr
+            } else {
+                method
+            }
+    }
+}

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

@@ -16,17 +16,21 @@
 package org.domaframework.doma.intellij.common.psi
 
 import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiField
+import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiType
 import com.intellij.psi.util.PsiTypesUtil
+import org.domaframework.doma.intellij.common.util.MethodMatcher
+import org.domaframework.doma.intellij.extension.expr.extractParameterTypes
 
 /**
  * When parsing a field access element with SQL,
  * manage the reference class information of the previous element
  */
-class PsiParentClass(
+open class PsiParentClass(
     val type: PsiType,
 ) {
     var clazz: PsiClass? = psiClass()
@@ -61,6 +65,34 @@ class PsiParentClass(
                 m.name.substringBefore("(") == methodName.substringBefore("(")
             }
 
+    fun findMethod(
+        methodExpr: PsiElement,
+        shortName: String = "",
+    ): MethodMatcher.MatchResult {
+        val context = MethodParamContext.of(methodExpr)
+        val methods = findMethods(context.methodIdExp.text)
+        if (context.methodParams == null) return MethodMatcher.MatchResult(validation = null)
+
+        val actualCount = context.methodParams.elExprList.size
+        val paramTypes = context.methodParams.extractParameterTypes(PsiManager.getInstance(methodExpr.project))
+        val matchResult =
+            MethodMatcher.findMatchingMethod(
+                context.methodIdExp,
+                methods,
+                paramTypes,
+                actualCount,
+                shortName,
+            )
+
+        return matchResult
+    }
+
+    fun findMethods(methodName: String): List<PsiMethod> =
+        getMethods()
+            ?.filter { m ->
+                m.hasModifierProperty(PsiModifier.PUBLIC) && m.name.substringBefore("(") == methodName.substringBefore("(")
+            } ?: emptyList()
+
     fun searchMethod(methodName: String): List<PsiMethod>? =
         getMethods()?.filter { m ->
             m.name.substringBefore("(").startsWith(methodName.substringBefore("(")) &&
@@ -81,4 +113,11 @@ class PsiParentClass(
                 m.hasModifierProperty(PsiModifier.PUBLIC) &&
                 m.name.substringBefore("(").startsWith(methodName.substringBefore("("))
         }
+
+    fun findStaticMethods(methodName: String): List<PsiMethod> =
+        getMethods()
+            ?.filter { m ->
+                m.hasModifierProperty(PsiModifier.STATIC) &&
+                    m.hasModifierProperty(PsiModifier.PUBLIC) && m.name.substringBefore("(") == methodName.substringBefore("(")
+            } ?: emptyList()
 }

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

@@ -34,7 +34,7 @@ class FunctionCallCollector(
     private val bind: String,
 ) : StaticDirectiveHandlerCollector() {
     public override fun collect(): List<LookupElement>? {
-        var functions = mutableSetOf<PsiMethod>()
+        val functions = mutableSetOf<PsiMethod>()
         val project = file?.project
         val module = file?.module ?: return null
         val isTest = CommonPathParameterUtil.isTest(module, file.virtualFile)
@@ -50,7 +50,10 @@ class FunctionCallCollector(
             project?.let { ExpressionFunctionsHelper.setExpressionFunctionsInterface(it) }
                 ?: return null
 
-        val expressionClazz = customFunctionClassName?.let { project.getJavaClazz(it) }
+        val expressionClazz =
+            customFunctionClassName?.let {
+                if (it.isNotEmpty()) project.getJavaClazz(it) else null
+            }
         if (expressionClazz != null &&
             ExpressionFunctionsHelper.isInheritor(expressionClazz)
         ) {
@@ -71,17 +74,17 @@ class FunctionCallCollector(
         return functions
             .filter {
                 it.name.startsWith(bind.substringAfter("@"))
-            }.map {
-                val parameters = it.parameterList.parameters.toList()
+            }.map { m ->
+                val parameters = m.parameterList.parameters.toList()
                 LookupElementBuilder
-                    .create(createMethodLookupElement(caretNextText, it))
-                    .withPresentableText(it.name)
+                    .create(createMethodLookupElement(caretNextText, m))
+                    .withPresentableText(m.name)
                     .withTailText(
                         "(${
-                            parameters.joinToString(",") { "${it.type.presentableText} ${it.name}" }
+                            parameters.joinToString(",") { p -> "${p.type.presentableText} ${p.name}" }
                         })",
                         true,
-                    ).withTypeText(it.returnType?.presentableText ?: "void")
+                    ).withTypeText(m.returnType?.presentableText ?: "void")
                     .withAutoCompletionPolicy(AutoCompletionPolicy.ALWAYS_AUTOCOMPLETE)
             }
     }