Highlight Specific Parameter Types in SQL Bind Variables as Errors

Author: xterao

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

@@ -18,7 +18,11 @@ package org.domaframework.doma.intellij.extension.psi
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiParameter
 
-fun PsiMethod.findParameter(searchName: String): PsiParameter? = this.methodParameters.firstOrNull { it.name == searchName }
+fun PsiMethod.findParameter(searchName: String): PsiParameter? =
+    this.methodParameters.firstOrNull {
+        it.name == searchName &&
+            !it.isIgnoreUsageCheck()
+    }
 
 val PsiMethod.methodParameters: List<PsiParameter>
     get() = this.parameterList.parameters.toList()

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

@@ -32,15 +32,15 @@ fun PsiParameter.isIgnoreUsageCheck(): Boolean =
         when (type) {
             DomaClassName.SELECT_OPTIONS -> {
                 // Only ignore the exact SelectOptions class, not its subtypes
-                val clazzType = this.typeElement?.type as? PsiClassType
+                val clazzType = this.type as? PsiClassType
                 clazzType?.rawType()?.canonicalText == type.className
             }
             else -> getSuperClassType(type) != null
         }
     }
 
 fun PsiParameter.getSuperClassType(superClassType: DomaClassName): PsiClassType? {
-    val clazzType = this.typeElement?.type as? PsiClassType
+    val clazzType = this.type as? PsiClassType
     var superCollection: PsiClassType? = clazzType
     while (superCollection != null &&
         !superClassType.isTargetClassNameStartsWith(superCollection.canonicalText)

src/test/kotlin/org/domaframework/doma/intellij/inspection/sql/ParameterDefinedTest.kt

@@ -24,7 +24,7 @@ import org.domaframework.doma.intellij.inspection.sql.inspector.SqlLoopDirective
  * A test that inspects whether a bind variable's parameters are defined.
  */
 class ParameterDefinedTest : DomaSqlTest() {
-    private val testDaoName = "EmployeeSummaryDao"
+    private val testDaoName = "inspection/ParamDefinedTestDao"
 
     override fun setUp() {
         super.setUp()

src/test/kotlin/org/domaframework/doma/intellij/inspection/sql/SpecificParameterTypeDefinedTest.kt

@@ -0,0 +1,95 @@
+/*
+ * 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.inspection.sql
+
+import org.domaframework.doma.intellij.DomaSqlTest
+import org.domaframework.doma.intellij.inspection.sql.inspector.SqlBindVariableInspection
+import org.domaframework.doma.intellij.inspection.sql.inspector.SqlFunctionCallInspection
+import org.domaframework.doma.intellij.inspection.sql.inspector.SqlLoopDirectiveTypeInspection
+
+/**
+ * Test cases for error highlighting when specific parameter types are used within SQL files.
+ *
+ * This test class verifies that the inspection correctly identifies and highlights errors
+ * when method parameters of specific types (such as Optional, List, Entity classes, etc.)
+ * are referenced in SQL bind variables and directives.
+ */
+class SpecificParameterTypeDefinedTest : DomaSqlTest() {
+    private val testDaoName = "inspection/option/SpecificParamTypeBindVariableInspectionTestDao"
+
+    override fun setUp() {
+        super.setUp()
+        addDaoJavaFile("$testDaoName.java")
+        addOtherJavaFile("function", "HogeFunction.java")
+        addOtherJavaFile("function", "HogeBiFunction.java")
+        addOtherJavaFile("option", "HogeSelectOptions.java")
+        addOtherJavaFile("collector", "HogeCollector.java")
+        myFixture.enableInspections(
+            SqlBindVariableInspection(),
+            SqlLoopDirectiveTypeInspection(),
+            SqlFunctionCallInspection(),
+        )
+    }
+
+    fun testSelectOptions() {
+        val sqlFileName = "$testDaoName/selectSelectOption.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testSubTypeSelectOption() {
+        val sqlFileName = "$testDaoName/selectSubTypeSelectOption.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testCollector() {
+        val sqlFileName = "$testDaoName/selectCollector.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testSubTypeCollector() {
+        val sqlFileName = "$testDaoName/selectSubTypeCollector.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testFunction() {
+        val sqlFileName = "$testDaoName/selectFunction.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testSubTypeFunction() {
+        val sqlFileName = "$testDaoName/selectSubTypeFunction.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testBiFunction() {
+        val sqlFileName = "$testDaoName/executeBiFunction.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    fun testSubTypeBiFunction() {
+        val sqlFileName = "$testDaoName/executeSubTypeBiFunction.sql"
+        inspectionSql(sqlFileName)
+    }
+
+    private fun inspectionSql(sqlFileName: String) {
+        addSqlFile(sqlFileName)
+        val sqlFile = findSqlFile(sqlFileName)
+        assertNotNull("Not Found SQL File", sqlFile)
+        if (sqlFile == null) return
+
+        myFixture.testHighlighting(false, false, false, sqlFile)
+    }
+}

src/test/testData/src/main/java/doma/example/dao/EmployeeSummaryDao.java renamed to src/test/testData/src/main/java/doma/example/dao/inspection/ParamDefinedTestDao.java

@@ -1,4 +1,4 @@
-package doma.example.dao;
+package doma.example.dao.inspection;
 
 import doma.example.entity.*:
 import org.seasar.doma.*;
@@ -11,7 +11,7 @@
 import java.util.function.BiFunction;
 
 @Dao
-interface EmployeeSummaryDao {
+interface ParamDefinedTestDao {
 
   @Select
   EmployeeSummary bindVariableForNonEntityClass(EmployeeSummary employee, User user);

src/test/testData/src/main/java/doma/example/dao/inspection/option/SpecificParamTypeBindVariableInspectionTestDao.java

@@ -0,0 +1,108 @@
+package doma.example.dao.inspection.option;
+
+import doma.example.collector.HogeCollector;
+import doma.example.entity.*;
+import doma.example.function.HogeFunction;
+import doma.example.option.HogeSelectOptions;
+import org.seasar.doma.*;
+import org.seasar.doma.jdbc.Config;
+import org.seasar.doma.jdbc.PreparedSql;
+import org.seasar.doma.jdbc.SelectOptions;
+import doma.example.function.HogeBiFunction;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
+
+/**
+ * Tests that specific types are correctly highlighted as errors when used as bind variables in SQL.
+ * Verifies that SelectOptions, Collector, Function, and BiFunction types (and their subtypes)
+ */
+@Dao
+public interface SpecificParamTypeBindVariableInspectionTestDao {
+
+  /**
+   * SelectOptions do not cause errors even when unused
+   * @param searchName
+   * @param options
+   * @return
+   */
+  @Select
+  Project selectSelectOption(Integer id, String searchName, SelectOptions options);
+
+  /**
+   * SelectOptions subtypes cause errors even when unused
+   * @param searchName
+   * @param hogeSelectOptions
+   * @return
+   */
+  @Select
+  Project selectSubTypeSelectOption(Employee employee,
+      String searchName,
+      HogeSelectOptions hogeSelectOptions);
+
+  /**
+   * Collector do not cause errors even when unused in SQL
+   * @param salary
+   * @param collector
+   * @return
+   */
+  @Select(strategy = SelectType.COLLECT)
+  Pckt selectCollector(BigDecimal salary, Collector<Packet, BigDecimal, Pckt> collector);
+
+  /**
+   * Collector subclasses do not cause errors even when unused in SQL
+   * @param employee
+   * @param id
+   * @param hogeCollector
+   * @return
+   */
+  @Select(strategy = SelectType.COLLECT)
+  String selectSubTypeCollector(Employee employee,
+      Integer id,
+      HogeCollector hogeCollector);
+
+  /**
+   * Function parameters do not cause errors even when unused
+   * @param employee
+   * @param id
+   * @param function
+   * @return
+   */
+  @Select(strategy = SelectType.STREAM)
+  String selectFunction(Employee employee,
+      Integer id,
+      Function<Stream<Employee>, String> function);
+
+  /**
+   * Function subtypes do not cause errors even when unused
+   * @param employee
+   * @param id
+   * @param function
+   * @return
+   */
+  @Select(strategy = SelectType.STREAM)
+  String selectSubTypeFunction(Employee employee,
+      Integer id,
+      HogeFunction function);
+
+  /**
+   * BiFunction parameters do not cause errors even when unused
+   * @param tableName
+   * @param func
+   * @return
+   */
+  @SqlProcessor
+  Pckt executeBiFunction(String tableName, BiFunction<Config, PreparedSql, Pckt> func);
+
+  /**
+   * BiFunction subtypes do not cause errors even when unused
+   * @param tableName
+   * @param func
+   * @return
+   */
+  @SqlProcessor
+  String executeSubTypeBiFunction(String tableName, HogeBiFunction func);
+
+}