Merge pull request #448 from domaframework/feature/inspection-function-call-param

Check Parameter Types for Method Calls in Bind Variables

Author: xterao

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)
             }
     }

src/main/kotlin/org/domaframework/doma/intellij/common/util/FieldMethodResolver.kt

@@ -0,0 +1,204 @@
+/*
+ * 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.util
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClassType
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiManager
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiType
+import org.domaframework.doma.intellij.common.psi.MethodParamContext
+import org.domaframework.doma.intellij.common.psi.PsiParentClass
+import org.domaframework.doma.intellij.common.sql.PsiClassTypeUtil
+import org.domaframework.doma.intellij.common.validation.result.ValidationCompleteResult
+import org.domaframework.doma.intellij.common.validation.result.ValidationNotFoundStaticPropertyResult
+import org.domaframework.doma.intellij.common.validation.result.ValidationPropertyResult
+import org.domaframework.doma.intellij.common.validation.result.ValidationResult
+import org.domaframework.doma.intellij.extension.expr.extractParameterTypes
+import org.domaframework.doma.intellij.psi.SqlElParameters
+
+class FieldMethodResolver {
+    data class ResolveContext(
+        var parent: PsiParentClass,
+        var parentListBaseType: PsiType?,
+        var nestIndex: Int,
+        var completeResult: ValidationCompleteResult? = null,
+        var validationResult: ValidationResult? = null,
+    )
+
+    data class ResolveResult(
+        val type: PsiParentClass? = null,
+        val validation: ValidationResult? = null,
+    )
+
+    companion object {
+        fun resolveField(
+            context: ResolveContext,
+            fieldName: String,
+            project: Project,
+        ): PsiParentClass? {
+            val field = context.parent.findField(fieldName) ?: return null
+            val convertedType = PsiClassTypeUtil.convertOptionalType(field.type, project)
+
+            val resolvedType =
+                context.parentListBaseType?.let {
+                    PsiClassTypeUtil.getParameterType(project, convertedType, it, context.nestIndex)
+                } ?: convertedType
+
+            updateContextForIterableType(context, resolvedType, project)
+            return PsiParentClass(resolvedType)
+        }
+
+        /**
+         * Retrieve, from the defined methods with that name, those whose parameter count and parameter types match.
+         */
+        fun resolveMethod(
+            context: ResolveContext,
+            element: PsiElement,
+            methodName: String,
+            project: Project,
+            shortName: String = "",
+        ): ResolveResult {
+            val methodContext: MethodParamContext = MethodParamContext.of(element)
+            val candidateMethods = context.parent.findMethods(methodName)
+            if (candidateMethods.isEmpty()) {
+                return ResolveResult(
+                    validation = ValidationPropertyResult(element, context.parent, shortName),
+                )
+            }
+            return resolveMethodWithParameters(
+                context,
+                element,
+                candidateMethods,
+                methodContext.methodParams,
+                project,
+                shortName,
+            )
+        }
+
+        fun resolveStaticMethod(
+            context: ResolveContext,
+            element: PsiElement,
+            parent: PsiParentClass,
+            methodName: String,
+            parametersExpr: SqlElParameters?,
+            project: Project,
+            shortName: String = "",
+        ): ResolveResult {
+            val candidateMethods = parent.findStaticMethods(methodName)
+
+            if (parametersExpr == null) {
+                return ResolveResult()
+            }
+
+            if (candidateMethods.isEmpty()) {
+                return ResolveResult(
+                    validation = ValidationNotFoundStaticPropertyResult(element, parent.type.canonicalText, shortName),
+                )
+            }
+
+            val paramTypes =
+                parametersExpr.extractParameterTypes(
+                    PsiManager.getInstance(project),
+                )
+
+            val matchResult =
+                MethodMatcher.findMatchingMethod(
+                    element,
+                    candidateMethods,
+                    paramTypes,
+                    parametersExpr.elExprList.size,
+                    shortName,
+                )
+
+            fun result(): ResolveResult {
+                if (matchResult.validation != null) {
+                    context.validationResult = matchResult.validation
+                    return ResolveResult(validation = matchResult.validation)
+                }
+
+                val returnType = matchResult.method?.returnType ?: return ResolveResult()
+
+                val convertedType = PsiClassTypeUtil.convertOptionalType(returnType, project)
+                val resolvedType =
+                    context.parentListBaseType?.let {
+                        PsiClassTypeUtil.getParameterType(project, convertedType, it, context.nestIndex)
+                    } ?: convertedType
+
+                updateContextForIterableType(context, resolvedType, project)
+                return ResolveResult(type = PsiParentClass(resolvedType))
+            }
+
+            return result()
+        }
+
+        private fun resolveMethodWithParameters(
+            context: ResolveContext,
+            element: PsiElement,
+            candidateMethods: List<PsiMethod>,
+            paramExpr: SqlElParameters?,
+            project: Project,
+            shortName: String,
+        ): ResolveResult {
+            val paramTypes =
+                paramExpr?.extractParameterTypes(
+                    PsiManager.getInstance(project),
+                ) ?: emptyList()
+
+            val matchResult =
+                MethodMatcher.findMatchingMethod(
+                    element,
+                    candidateMethods,
+                    paramTypes,
+                    paramExpr?.elExprList?.size ?: 0,
+                    shortName,
+                )
+
+            fun result(): ResolveResult {
+                if (matchResult.validation != null) {
+                    context.validationResult = matchResult.validation
+                    return ResolveResult(validation = matchResult.validation)
+                }
+
+                val returnType = matchResult.method?.returnType ?: return ResolveResult()
+
+                val convertedType = PsiClassTypeUtil.convertOptionalType(returnType, project)
+                val resolvedType =
+                    context.parentListBaseType?.let {
+                        PsiClassTypeUtil.getParameterType(project, convertedType, it, context.nestIndex)
+                    } ?: convertedType
+
+                updateContextForIterableType(context, resolvedType, project)
+                return ResolveResult(type = PsiParentClass(resolvedType))
+            }
+
+            return result()
+        }
+
+        private fun updateContextForIterableType(
+            context: ResolveContext,
+            type: PsiType,
+            project: Project,
+        ) {
+            val classType = type as? PsiClassType
+            if (classType != null && PsiClassTypeUtil.isIterableType(classType, project)) {
+                context.parentListBaseType = PsiClassTypeUtil.convertOptionalType(type, project)
+                context.nestIndex = 0
+            }
+        }
+    }
+}