Enhance the usage checks of DAO method parameters for subtypes.

xterao · xterao · commit a765a024eb7e · 2025-06-24T14:13:07.000+09:00
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/common/util/DomaClassName.kt b/src/main/kotlin/org/domaframework/doma/intellij/common/util/DomaClassName.kt
@@ -38,6 +38,7 @@ enum class DomaClassName(
     VOID("java.lang.Void"),
     RETURNING("org.seasar.doma.Returning"),
     REFERENCE("org.seasar.doma.jdbc.Reference"),
+    SELECT_OPTIONS("org.seasar.doma.jdbc.SelectOptions"),
 
     STRING("java.lang.String"),
     OBJECT("java.lang.Object"),
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/extension/psi/PsiParameterExtension.kt b/src/main/kotlin/org/domaframework/doma/intellij/extension/psi/PsiParameterExtension.kt
@@ -17,22 +17,43 @@ package org.domaframework.doma.intellij.extension.psi
 
 import com.intellij.psi.PsiClassType
 import com.intellij.psi.PsiParameter
+import org.domaframework.doma.intellij.common.util.DomaClassName
 
 val PsiParameter.isFunctionClazz: Boolean
-    get() =
-        (this.typeElement?.type as? PsiClassType)
-            ?.resolve()
-            ?.qualifiedName
-            ?.contains("java.util.function") == true
+    get() {
+        val functionType = DomaClassName.JAVA_FUNCTION
+        val superCollection: PsiClassType? = getSuperClassType(functionType)
+        return functionType.isTargetClassNameStartsWith(superCollection?.canonicalText ?: "")
+    }
+
+val PsiParameter.isBiFunctionClazz: Boolean
+    get() {
+        val functionType = DomaClassName.BI_FUNCTION
+        val superCollection: PsiClassType? = getSuperClassType(functionType)
+        return functionType.isTargetClassNameStartsWith(superCollection?.canonicalText ?: "")
+    }
 
 val PsiParameter.isSelectOption: Boolean
     get() =
         (this.typeElement?.type as? PsiClassType)
             ?.resolve()
-            ?.qualifiedName == "org.seasar.doma.jdbc.SelectOptions"
+            ?.qualifiedName == DomaClassName.SELECT_OPTIONS.className
 
 val PsiParameter.isCollector: Boolean
-    get() =
-        (this.typeElement?.type as? PsiClassType)
-            ?.resolve()
-            ?.qualifiedName == "java.util.stream.Collector"
+    get() {
+        val collectorType = DomaClassName.JAVA_COLLECTOR
+        val superCollection: PsiClassType? = getSuperClassType(collectorType)
+        return collectorType.isTargetClassNameStartsWith(superCollection?.canonicalText ?: "")
+    }
+
+fun PsiParameter.getSuperClassType(superClassType: DomaClassName): PsiClassType? {
+    val clazzType = this.typeElement?.type as? PsiClassType
+    var superCollection: PsiClassType? = clazzType
+    while (superCollection != null &&
+        !superClassType.isTargetClassNameStartsWith(superCollection.canonicalText)
+    ) {
+        superCollection =
+            superCollection.getSuperType(superClassType.className)
+    }
+    return superCollection
+}
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/visitor/UsedDaoMethodParamInspectionVisitor.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/visitor/UsedDaoMethodParamInspectionVisitor.kt
@@ -27,6 +27,7 @@ import org.domaframework.doma.intellij.common.dao.getDaoClass
 import org.domaframework.doma.intellij.common.isJavaOrKotlinFileType
 import org.domaframework.doma.intellij.common.psi.PsiDaoMethod
 import org.domaframework.doma.intellij.extension.findFile
+import org.domaframework.doma.intellij.extension.psi.isBiFunctionClazz
 import org.domaframework.doma.intellij.extension.psi.isCollector
 import org.domaframework.doma.intellij.extension.psi.isFunctionClazz
 import org.domaframework.doma.intellij.extension.psi.isSelectOption
@@ -45,7 +46,7 @@ class UsedDaoMethodParamInspectionVisitor(
 
         val methodParameters =
             method.methodParameters
-                .filter { !it.isFunctionClazz && !it.isSelectOption && !(it.isCollector && psiDaoMethod.isSelectTypeCollect()) }
+                .filter { !it.isFunctionClazz && !it.isBiFunctionClazz && !it.isSelectOption && !it.isCollector }
         val sqlFileManager =
             psiDaoMethod.sqlFile?.let {
                 method.project.findFile(it)
diff --git a/src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/DomaUseVariableTest.kt b/src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/DomaUseVariableTest.kt
@@ -36,7 +36,13 @@ class DomaUseVariableTest : DomaSqlTest() {
             "$testDaoName/collectDoesCauseError.sql",
             "$testDaoName/noErrorWhenUsedInFunctionParameters.sql",
             "$testDaoName/duplicateForDirectiveDefinitionNames.sql",
+            "$testDaoName/selectHogeFunction.sql",
+            "$testDaoName/functionDoesNotCauseError.sql",
+            "$testDaoName/selectHogeCollector.sql",
         )
+        addOtherJavaFile("collector", "HogeCollector.java")
+        addOtherJavaFile("function", "HogeFunction.java")
+        addOtherJavaFile("function", "HogeBiFunction.java")
         myFixture.enableInspections(UsedDaoMethodParamInspection())
     }
 
diff --git a/src/test/testData/src/main/java/doma/example/dao/DaoMethodVariableInspectionTestDao.java b/src/test/testData/src/main/java/doma/example/dao/DaoMethodVariableInspectionTestDao.java
@@ -17,7 +17,11 @@
 import org.seasar.doma.jdbc.PreparedSql;
 import org.seasar.doma.jdbc.SelectOptions;
 import org.seasar.doma.SelectType;
+import java.util.stream.Stream;
+import java.util.function.Function;
 import java.util.stream.Collector;
+import doma.example.function.*;
+import doma.example.collector.*;
 
 import java.util.List;
 import java.util.function.BiFunction;
@@ -38,20 +42,46 @@ interface DaoMethodVariableInspectionTestDao {
   @SqlProcessor
   <R> R biFunctionDoesNotCauseError(Integer id, BiFunction<Config, PreparedSql, R> handler);
 
+  @SqlProcessor
+  @Sql("SELECT id, name FROM demo")
+  <R> R biFunctionHogeFunction(HogeBiFunction handler);
+
   @Select
-  Project selectOptionDoesNotCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,String searchName,SelectOptions options);
+  Project selectOptionDoesNotCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,
+      String searchName,
+      SelectOptions options);
+
+  @Select(strategy = SelectType.COLLECT)
+  Project collectDoesNotCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,
+      Integer id,
+      Collector<Project, ?, Project> collector);
 
   @Select(strategy = SelectType.COLLECT)
-  Project collectDoesNotCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,Integer id,Collector<Project, ?, Project> collector);
+  Project selectHogeCollector(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,
+      Integer id,
+      HogeCollector collector);
 
   @Select
-  Project collectDoesCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,String searchName,Collector<Project, ?, Project> <error descr="There are unused parameters in the SQL [collector]">collector</error>);
+  Project collectDoesCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,
+      String searchName,
+      Collector<Project, ?, Project> collector);
+
+  @Select(strategy = SelectType.STREAM)
+  String functionDoesNotCauseError(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,
+      Integer id,
+      Function<Stream<Employee>, String> function);
+
+  @Select(strategy = SelectType.STREAM)
+  String selectHogeFunction(Employee <error descr="There are unused parameters in the SQL [employee]">employee</error>,
+      Integer id,
+      HogeFunction function);
 
   @Select
   Project noErrorWhenUsedInFunctionParameters(Employee employee, Integer count);
 
   @Select
-  Employee duplicateForDirectiveDefinitionNames(Employee <error descr="An element name that is a duplicate of an element name defined in SQL is used">member</error>, Integer <error descr="There are unused parameters in the SQL [count]">count</error>,
+  Employee duplicateForDirectiveDefinitionNames(Employee <error descr="An element name that is a duplicate of an element name defined in SQL is used">member</error>,
+      Integer <error descr="There are unused parameters in the SQL [count]">count</error>,
       List<Employee> users,
       String searchName,
       Boolean inForm);
diff --git a/src/test/testData/src/main/java/doma/example/dao/inspection/returntype/SelectReturnTypeTestDao.java b/src/test/testData/src/main/java/doma/example/dao/inspection/returntype/SelectReturnTypeTestDao.java
@@ -129,7 +129,7 @@ public interface SelectReturnTypeTestDao {
 
   @Select(strategy = SelectType.COLLECT)
   @Sql("select * from emp where salary > /* salary */0")
-  Pckt selectHogeCollect(BigDecimal salary, HogeCollector collector);
+  Pckt <error descr="The return type must match RESULT of the \"java.util.stream.Collector\" type parameter">selectHogeCollect</error>(BigDecimal salary, HogeCollector collector);
 
   @Select(strategy = SelectType.STREAM)
   @Sql("select * from emp where salary > /* salary */0")
diff --git a/src/test/testData/src/main/java/doma/example/function/HogeBiFunction.java b/src/test/testData/src/main/java/doma/example/function/HogeBiFunction.java
@@ -0,0 +1,17 @@
+package doma.example.function;
+
+import org.seasar.doma.jdbc.Config;
+import org.seasar.doma.jdbc.PreparedSql;
+
+import java.io.ObjectInputFilter;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class HogeBiFunction implements BiFunction<Config, PreparedSql, String> {
+
+  @Override
+  public String apply(Config config, PreparedSql preparedSql) {
+    return "";
+  }
+}
diff --git a/src/test/testData/src/main/resources/META-INF/doma/example/dao/DaoMethodVariableInspectionTestDao/functionDoesNotCauseError.sql b/src/test/testData/src/main/resources/META-INF/doma/example/dao/DaoMethodVariableInspectionTestDao/functionDoesNotCauseError.sql
@@ -0,0 +1,6 @@
+select
+ p.project_id
+ , p.project_name
+ , p.project_number
+from project p
+where p.project_id = /* id */0
diff --git a/src/test/testData/src/main/resources/META-INF/doma/example/dao/DaoMethodVariableInspectionTestDao/selectHogeCollector.sql b/src/test/testData/src/main/resources/META-INF/doma/example/dao/DaoMethodVariableInspectionTestDao/selectHogeCollector.sql
@@ -0,0 +1,6 @@
+select
+ p.project_id
+ , p.project_name
+ , p.project_number
+from project p
+where p.project_id = /* id */0
diff --git a/src/test/testData/src/main/resources/META-INF/doma/example/dao/DaoMethodVariableInspectionTestDao/selectHogeFunction.sql b/src/test/testData/src/main/resources/META-INF/doma/example/dao/DaoMethodVariableInspectionTestDao/selectHogeFunction.sql
@@ -0,0 +1,6 @@
+select
+ p.project_id
+ , p.project_name
+ , p.project_number
+from project p
+where p.project_id = /* id */0

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,13 @@ class DomaUseVariableTest : DomaSqlTest() {`
`36`	`36`	`"$testDaoName/collectDoesCauseError.sql",`
`37`	`37`	`"$testDaoName/noErrorWhenUsedInFunctionParameters.sql",`
`38`	`38`	`"$testDaoName/duplicateForDirectiveDefinitionNames.sql",`
	`39`	`+ "$testDaoName/selectHogeFunction.sql",`
	`40`	`+ "$testDaoName/functionDoesNotCauseError.sql",`
	`41`	`+ "$testDaoName/selectHogeCollector.sql",`
`39`	`42`	`)`
	`43`	`+ addOtherJavaFile("collector", "HogeCollector.java")`
	`44`	`+ addOtherJavaFile("function", "HogeFunction.java")`
	`45`	`+ addOtherJavaFile("function", "HogeBiFunction.java")`
`40`	`46`	`myFixture.enableInspections(UsedDaoMethodParamInspection())`
`41`	`47`	`}`
`42`	`48`