Merge pull request #350 from domaframework/fix/check-returntype-datatype

xterao · web-flow · commit fea91a584d33 · 2025-07-30T17:30:57.000+09:00
Support for Using `@DataType`-Annotated Records in DAO Method Return and Parameter Types
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
@@ -67,6 +67,7 @@ enum class DomaClassName(
     SELECT_TYPE("org.seasar.doma.SelectType"),
 
     ENTITY("org.seasar.doma.Entity"),
+    DATATYPE("org.seasar.doma.DataType"),
     ;
 
     fun isTargetClassNameStartsWith(paramTypeCanonicalNames: String): Boolean = paramTypeCanonicalNames.startsWith(this.className)
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/common/util/TypeUtil.kt b/src/main/kotlin/org/domaframework/doma/intellij/common/util/TypeUtil.kt
@@ -22,6 +22,7 @@ import com.intellij.psi.PsiType
 import org.domaframework.doma.intellij.common.psi.PsiTypeChecker
 import org.domaframework.doma.intellij.extension.getJavaClazz
 import org.domaframework.doma.intellij.extension.psi.getClassAnnotation
+import org.domaframework.doma.intellij.extension.psi.isDataType
 import org.domaframework.doma.intellij.extension.psi.isDomain
 import org.domaframework.doma.intellij.extension.psi.isEntity
 
@@ -73,6 +74,17 @@ object TypeUtil {
         return clazz?.isDomain() == true
     }
 
+    /**
+     * Checks if the given type is a data type.
+     */
+    fun isDataType(
+        type: PsiType?,
+        project: Project,
+    ): Boolean {
+        val clazz = type?.canonicalText?.let { project.getJavaClazz(it) }
+        return clazz?.isDataType() == true
+    }
+
     /**
      * Checks if the given type is a valid Map<String, Object>.
      */
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/extension/psi/PsiClassExtension.kt b/src/main/kotlin/org/domaframework/doma/intellij/extension/psi/PsiClassExtension.kt
@@ -50,6 +50,8 @@ fun PsiClass.isEntity(): Boolean = this.getClassAnnotation(DomaClassName.ENTITY.
 
 fun PsiClass.isDomain(): Boolean = this.getClassAnnotation(DomaClassName.DOMAIN.className) != null
 
+fun PsiClass.isDataType(): Boolean = this.getClassAnnotation(DomaClassName.DATATYPE.className) != null && this.isRecord
+
 fun PsiClassType.getSuperType(superClassName: String): PsiClassType? {
     var parent: PsiClassType? = this
     while (parent != null && !parent.canonicalText.startsWith(superClassName)) {
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/TypeCheckerProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/TypeCheckerProcessor.kt
@@ -26,6 +26,7 @@ import org.domaframework.doma.intellij.common.psi.PsiTypeChecker
 import org.domaframework.doma.intellij.common.util.DomaClassName
 import org.domaframework.doma.intellij.extension.getJavaClazz
 import org.domaframework.doma.intellij.extension.psi.getSuperType
+import org.domaframework.doma.intellij.extension.psi.isDataType
 import org.domaframework.doma.intellij.extension.psi.isDomain
 
 /**
@@ -90,12 +91,12 @@ abstract class TypeCheckerProcessor(
             val optionalParam = paramClassType.parameters.firstOrNull()
             return optionalParam?.let {
                 val optionalParamClass = project.getJavaClazz(it.canonicalText)
-                optionalParamClass?.isDomain() == true || PsiTypeChecker.isBaseClassType(it)
+                optionalParamClass?.isDomain() == true || optionalParamClass?.isDataType() == true || PsiTypeChecker.isBaseClassType(it)
             } == true
         }
 
         val paramClass = project.getJavaClazz(paramType.canonicalText)
-        return paramClass?.isDomain() == true
+        return paramClass?.isDomain() == true || paramClass?.isDataType() == true
     }
 
     protected fun checkMapType(paramTypeCanonicalText: String): Boolean {
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/cheker/ProcedureFunctionResultSetParamAnnotationTypeChecker.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/cheker/ProcedureFunctionResultSetParamAnnotationTypeChecker.kt
@@ -26,6 +26,7 @@ import org.domaframework.doma.intellij.common.util.DomaClassName
 import org.domaframework.doma.intellij.common.validation.result.ValidationMethodParamsSupportGenericParamResult
 import org.domaframework.doma.intellij.common.validation.result.ValidationMethodProcedureParamTypeResult
 import org.domaframework.doma.intellij.extension.getJavaClazz
+import org.domaframework.doma.intellij.extension.psi.isDataType
 import org.domaframework.doma.intellij.extension.psi.isDomain
 import org.domaframework.doma.intellij.extension.psi.isEntity
 
@@ -46,14 +47,15 @@ class ProcedureFunctionResultSetParamAnnotationTypeChecker(
                 val optionalParamClass = project.getJavaClazz(it.canonicalText)
                 optionalParamClass?.isDomain() == true ||
                     optionalParamClass?.isEntity() == true ||
+                    optionalParamClass?.isDataType() == true ||
                     PsiTypeChecker.isBaseClassType(
                         it,
                     )
             } == true
         }
 
         val paramClass = project.getJavaClazz(paramType.canonicalText)
-        return paramClass?.isDomain() == true
+        return paramClass?.isDomain() == true || paramClass?.isDataType() == true
     }
 
     override fun checkParam(
@@ -101,7 +103,7 @@ class ProcedureFunctionResultSetParamAnnotationTypeChecker(
 
         val paramClass = project.getJavaClazz(listParamType.canonicalText)
 
-        if (checkParamType(listParamType) || paramClass?.isEntity() == true) return
+        if (checkParamType(listParamType) || paramClass?.isEntity() == true || paramClass?.isDataType() == true) return
         result.highlightElement(holder)
     }
 }
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/paramtype/BatchParamTypeCheckProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/paramtype/BatchParamTypeCheckProcessor.kt
@@ -86,8 +86,17 @@ class BatchParamTypeCheckProcessor(
 
         val iterableClassType = param.type as? PsiClassType
         iterableClassType?.parameters?.firstOrNull()?.let { iterableParam ->
-            if (!TypeUtil.isEntity(iterableParam, project)) {
-                resultParamType.highlightElement(holder)
+            if (psiDaoMethod.useSqlAnnotation() || psiDaoMethod.sqlFileOption) {
+                if (!TypeUtil.isEntity(iterableParam, project) &&
+                    !TypeUtil.isDomain(iterableParam, project) &&
+                    !TypeUtil.isDataType(iterableParam, project)
+                ) {
+                    resultParamType.highlightElement(holder)
+                }
+            } else {
+                if (!TypeUtil.isEntity(iterableParam, project)) {
+                    resultParamType.highlightElement(holder)
+                }
             }
             return
         }
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/paramtype/SelectParamTypeCheckProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/paramtype/SelectParamTypeCheckProcessor.kt
@@ -27,6 +27,7 @@ import org.domaframework.doma.intellij.common.validation.result.ValidationMethod
 import org.domaframework.doma.intellij.common.validation.result.ValidationMethodSelectStrategyParamResult
 import org.domaframework.doma.intellij.extension.getJavaClazz
 import org.domaframework.doma.intellij.extension.psi.getSuperClassType
+import org.domaframework.doma.intellij.extension.psi.isDataType
 import org.domaframework.doma.intellij.extension.psi.isDomain
 import org.domaframework.doma.intellij.extension.psi.isEntity
 import org.domaframework.doma.intellij.inspection.dao.processor.StrategyParam
@@ -49,12 +50,13 @@ class SelectParamTypeCheckProcessor(
                 val optionalParamClass = project.getJavaClazz(it.canonicalText)
                 optionalParamClass?.isDomain() == true ||
                     PsiTypeChecker.isBaseClassType(it) ||
-                    optionalParamClass?.isEntity() == true
+                    optionalParamClass?.isEntity() == true ||
+                    optionalParamClass?.isDataType() == true
             } == true
         }
 
         val paramClass = project.getJavaClazz(paramType.canonicalText)
-        return paramClass?.isDomain() == true || paramClass?.isEntity() == true
+        return paramClass?.isDomain() == true || paramClass?.isEntity() == true || paramClass?.isDataType() == true
     }
 
     override fun checkParams(holder: ProblemsHolder) {
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/returntype/FunctionReturnTypeCheckProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/returntype/FunctionReturnTypeCheckProcessor.kt
@@ -67,7 +67,7 @@ class FunctionReturnTypeCheckProcessor(
             }
         }
 
-        if (TypeUtil.isDomain(checkType, project) || TypeUtil.isEntity(checkType, project)) {
+        if (TypeUtil.isDomain(checkType, project) || TypeUtil.isEntity(checkType, project) || TypeUtil.isDataType(checkType, project)) {
             return null
         }
 
diff --git a/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/returntype/SelectReturnTypeCheckProcessor.kt b/src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/returntype/SelectReturnTypeCheckProcessor.kt
@@ -91,7 +91,7 @@ class SelectReturnTypeCheckProcessor(
             }
         }
 
-        if (TypeUtil.isDomain(checkType, project) || TypeUtil.isEntity(checkType, project)) {
+        if (TypeUtil.isDomain(checkType, project) || TypeUtil.isEntity(checkType, project) || TypeUtil.isDataType(checkType, project)) {
             return null
         }
 
diff --git a/src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/AnnotationParamTypeCheckInspectionTest.kt b/src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/AnnotationParamTypeCheckInspectionTest.kt
@@ -32,6 +32,7 @@ class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {
             "ScriptParamTestDao",
             "SqlProcessorParamTestDao",
             "FactoryParamTestDao",
+            "DataTypeParamTypeTestDao",
         )
     private val daoPackage = "inspection/paramtype"
 
@@ -43,6 +44,7 @@ class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {
         addOtherJavaFile("collector", "HogeCollector.java")
         addOtherJavaFile("function", "HogeFunction.java")
         addOtherJavaFile("function", "HogeBiFunction.java")
+        addOtherJavaFile("domain", "Salary.java")
         testDaoNames.forEach { daoName ->
             addDaoJavaFile("$daoPackage/$daoName.java")
         }
@@ -87,4 +89,9 @@ class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {
         val dao = findDaoClass("$daoPackage.FactoryParamTestDao")
         myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
     }
+
+    fun testDataTypeParam() {
+        val dao = findDaoClass("$daoPackage.DataTypeParamTypeTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
 }
diff --git a/src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/AnnotationReturnTypeCheckInspectionTest.kt b/src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/AnnotationReturnTypeCheckInspectionTest.kt
@@ -32,6 +32,7 @@ class AnnotationReturnTypeCheckInspectionTest : DomaSqlTest() {
             "ProcedureReturnTypeTestDao",
             "FunctionReturnTypeTestDao",
             "FactoryReturnTypeTestDao",
+            "DataTypeReturnTypeTestDao",
         )
     private val daoPackage = "inspection/returntype"
 
@@ -43,6 +44,7 @@ class AnnotationReturnTypeCheckInspectionTest : DomaSqlTest() {
         addEntityJavaFile("Packet.java")
         addEntityJavaFile("Pckt.java")
         addOtherJavaFile("domain", "Hiredate.java")
+        addOtherJavaFile("domain", "Salary.java")
         addOtherJavaFile("collector", "HogeCollector.java")
         addOtherJavaFile("function", "HogeFunction.java")
         addOtherJavaFile("function", "HogeBiFunction.java")
@@ -88,4 +90,9 @@ class AnnotationReturnTypeCheckInspectionTest : DomaSqlTest() {
         val dao = findDaoClass("$daoPackage.FactoryReturnTypeTestDao")
         myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
     }
+
+    fun testDataTypeReturnTypeCheckProcessor() {
+        val dao = findDaoClass("$daoPackage.DataTypeReturnTypeTestDao")
+        myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)
+    }
 }
diff --git a/src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/DataTypeParamTypeTestDao.java b/src/test/testData/src/main/java/doma/example/dao/inspection/paramtype/DataTypeParamTypeTestDao.java
@@ -0,0 +1,76 @@
+package doma.example.dao.inspection.paramtype;
+
+import org.seasar.doma.*;
+import doma.example.domain.Salary;
+import org.seasar.doma.jdbc.Reference;
+import org.seasar.doma.jdbc.Result;
+
+import java.util.List;
+import java.util.Optional;
+
+@Dao
+public interface DataTypeParamTypeTestDao {
+
+  @Select
+  @Sql("select * from salary where id = /*salary.value*/0")
+  Salary selectSalary(Salary salary);
+
+  @Select
+  @Sql("select * from salary where id = /*salary.value*/0")
+  Optional<Salary> selectOptSalary(Salary salary);
+
+  @Update
+  int updateSalary(Salary <error descr="The parameter type must be an entity">salary</error>);
+
+  @Insert
+  int insertSalary(Salary <error descr="The parameter type must be an entity">salary</error>);
+
+  @Delete
+  int deleteSalary(Salary <error descr="The parameter type must be an entity">salary</error>);
+
+  @BatchUpdate
+  int[] batchUpdateSalary(List<Salary> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">salary</error>);
+
+  @BatchUpdate
+  int[] batchInsertSalary(List<Salary> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">salary</error>);
+
+  @BatchUpdate
+  int[] batchDeleteSalary(List<Salary> <error descr="The argument must be an Iterable subclass that has an Entity class as a parameter">salary</error>);
+
+  @Update
+  @Sql("UPDATE salary SET val = /*salary.value*/0")
+  int updateSalaryWithSql(Salary salary);
+
+  @Insert
+  @Sql("INSERT INTO salary (val) VALUES (/*salary.value*/0)")
+  int insertSalaryWithSql(Salary salary);
+
+  @Delete
+  @Sql("DELETE FROM salary WHERE val = /*salary.value*/0 ")
+  int deleteSalaryWithSql(Salary salary);
+
+  @BatchUpdate
+  @Sql("UPDATE salary SET val = /*salary.value*/0")
+  int[] batchUpdateSalaryWithSql(List<Salary> salary);
+
+  @BatchUpdate
+  @Sql("INSERT INTO salary (val) VALUES (/*salary.value*/0)")
+  int[] batchInsertSalaryWithSql(List<Salary> salary);
+
+  @BatchUpdate
+  @Sql("DELETE FROM salary WHERE val = /*salary.value*/0 ")
+  int[] batchDeleteSalaryWithSql(List<Salary> salary);
+
+  @Function
+  List<Salary> getTopSalaries(@In Salary limit);
+
+  @Function
+  Optional<Salary> getMaxSalary(@InOut Reference<Salary> percentage, @ResultSet List<Salary> resultSet);
+
+  @Procedure
+  void computeBonus(@In Salary employeeId);
+
+  @Procedure
+  void adjustSalaries(@InOut Reference<Salary> percentage, @ResultSet List<Salary> resultSet);
+
+}
diff --git a/src/test/testData/src/main/java/doma/example/dao/inspection/returntype/DataTypeReturnTypeTestDao.java b/src/test/testData/src/main/java/doma/example/dao/inspection/returntype/DataTypeReturnTypeTestDao.java
@@ -0,0 +1,82 @@
+package doma.example.dao.inspection.returntype;
+
+import org.seasar.doma.*;
+import doma.example.domain.Salary;
+import org.seasar.doma.jdbc.Reference;
+import org.seasar.doma.jdbc.Result;
+
+import java.util.List;
+import java.util.Optional;
+
+@Dao
+public interface DataTypeReturnTypeTestDao {
+
+  @Select
+  @Sql("select * from salary where id = /*salary.value*/0")
+  Salary selectSalary(Salary salary);
+
+  @Select
+  @Sql("select * from salary where id = /*salary.value*/0")
+  Optional<Salary> selectOptSalary(Salary salary) ;
+
+  @Update
+  @Sql("UPDATE salary SET val = /*salary.value*/0")
+  int updateSalaryWithSql1(Salary salary);
+
+  @Update
+  @Sql("UPDATE salary SET val = /*salary.value*/0")
+  Result<Salary> <error descr="The return type must be \"int\"">updateSalaryWithSql2</error>(Salary salary);
+
+  @Insert
+  @Sql("INSERT INTO salary (val) VALUES (/*salary.value*/0)")
+  int insertSalaryWithSql(Salary salary);
+
+  @Insert
+  @Sql("INSERT INTO salary (val) VALUES (/*salary.value*/0)")
+  Result<Salary> <error descr="The return type must be \"int\"">insertSalaryWithSql2</error>(Salary salary);
+
+  @Delete
+  @Sql("DELETE FROM salary WHERE val = /*salary.value*/0 ")
+  int deleteSalaryWithSql(Salary salary);
+
+  @Delete
+  @Sql("DELETE FROM salary WHERE val = /*salary.value*/0 ")
+  Result<Salary> <error descr="The return type must be \"int\"">deleteSalaryWithSql2</error>(Salary salary);
+
+  @BatchUpdate
+  @Sql("UPDATE salary SET val = /*salary.value*/0")
+  int[] batchUpdateSalaryWithSql(List<Salary> salary);
+
+  @BatchUpdate
+  @Sql("UPDATE salary SET val = /*salary.value*/0")
+  <error descr="Cannot resolve symbol 'BatchResult'">BatchResult</error><Salary> <error descr="The return type must be \"int[]\"">batchUpdateSalaryWithSql2</error>(List<Salary> salary);
+
+  @BatchInsert
+  @Sql("INSERT INTO salary (val) VALUES (/*salary.value*/0)")
+  int[] batchInsertSalaryWithSql(List<Salary> salary);
+
+  @BatchInsert
+  @Sql("INSERT INTO salary (val) VALUES (/*salary.value*/0)")
+  <error descr="Cannot resolve symbol 'BatchResult'">BatchResult</error><Salary> <error descr="The return type must be \"int[]\"">batchInsertSalaryWithSql2</error>(List<Salary> salary);
+
+  @BatchDelete
+  @Sql("DELETE FROM salary WHERE val = /*salary.value*/0 ")
+  int[] batchDeleteSalaryWithSql(List<Salary> salary);
+
+  @BatchDelete
+  @Sql("DELETE FROM salary WHERE val = /*salary.value*/0 ")
+  <error descr="Cannot resolve symbol 'BatchResult'">BatchResult</error><Salary> <error descr="The return type must be \"int[]\"">batchDeleteSalaryWithSql2</error>(List<Salary> salary);
+
+  @Function
+  List<Salary> getTopSalaries(@In Salary limit);
+
+  @Function
+  Optional<Salary> getMaxSalary(@InOut Reference<Salary> percentage, @ResultSet List<Salary> resultSet);
+
+  @Procedure
+  void computeBonus(@In Salary employeeId);
+
+  @Procedure
+  void adjustSalaries(@InOut Reference<Salary> percentage, @ResultSet List<Salary> resultSet);
+
+}
diff --git a/src/test/testData/src/main/java/doma/example/domain/Salary.java b/src/test/testData/src/main/java/doma/example/domain/Salary.java
@@ -0,0 +1,8 @@
+package doma.example.domain;
+
+import java.math.BigDecimal;
+import org.seasar.doma.DataType;
+
+@DataType
+public record Salary(BigDecimal value) {
+}

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,7 @@ enum class DomaClassName(`
`67`	`67`	`SELECT_TYPE("org.seasar.doma.SelectType"),`
`68`	`68`
`69`	`69`	`ENTITY("org.seasar.doma.Entity"),`
	`70`	`+ DATATYPE("org.seasar.doma.DataType"),`
`70`	`71`	`;`
`71`	`72`
`72`	`73`	`fun isTargetClassNameStartsWith(paramTypeCanonicalNames: String): Boolean = paramTypeCanonicalNames.startsWith(this.className)`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ import org.domaframework.doma.intellij.common.util.DomaClassName`
`26`	`26`	`import org.domaframework.doma.intellij.common.validation.result.ValidationMethodParamsSupportGenericParamResult`
`27`	`27`	`import org.domaframework.doma.intellij.common.validation.result.ValidationMethodProcedureParamTypeResult`
`28`	`28`	`import org.domaframework.doma.intellij.extension.getJavaClazz`
	`29`	`+import org.domaframework.doma.intellij.extension.psi.isDataType`
`29`	`30`	`import org.domaframework.doma.intellij.extension.psi.isDomain`
`30`	`31`	`import org.domaframework.doma.intellij.extension.psi.isEntity`
`31`	`32`
`@@ -46,14 +47,15 @@ class ProcedureFunctionResultSetParamAnnotationTypeChecker(`
`46`	`47`	`val optionalParamClass = project.getJavaClazz(it.canonicalText)`
`47`	`48`	`optionalParamClass?.isDomain() == true \|\|`
`48`	`49`	`optionalParamClass?.isEntity() == true \|\|`
	`50`	`+ optionalParamClass?.isDataType() == true \|\|`
`49`	`51`	`PsiTypeChecker.isBaseClassType(`
`50`	`52`	`it,`
`51`	`53`	`)`
`52`	`54`	`} == true`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`val paramClass = project.getJavaClazz(paramType.canonicalText)`
`56`		`- return paramClass?.isDomain() == true`
	`58`	`+ return paramClass?.isDomain() == true \|\| paramClass?.isDataType() == true`
`57`	`59`	`}`
`58`	`60`
`59`	`61`	`override fun checkParam(`
`@@ -101,7 +103,7 @@ class ProcedureFunctionResultSetParamAnnotationTypeChecker(`
`101`	`103`
`102`	`104`	`val paramClass = project.getJavaClazz(listParamType.canonicalText)`
`103`	`105`
`104`		`- if (checkParamType(listParamType) \|\| paramClass?.isEntity() == true) return`
	`106`	`+ if (checkParamType(listParamType) \|\| paramClass?.isEntity() == true \|\| paramClass?.isDataType() == true) return`
`105`	`107`	`result.highlightElement(holder)`
`106`	`108`	`}`
`107`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ class FunctionReturnTypeCheckProcessor(`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`		`- if (TypeUtil.isDomain(checkType, project) \|\| TypeUtil.isEntity(checkType, project)) {`
	`70`	`+ if (TypeUtil.isDomain(checkType, project) \|\| TypeUtil.isEntity(checkType, project) \|\| TypeUtil.isDataType(checkType, project)) {`
`71`	`71`	`return null`
`72`	`72`	`}`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ class SelectReturnTypeCheckProcessor(`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`- if (TypeUtil.isDomain(checkType, project) \|\| TypeUtil.isEntity(checkType, project)) {`
	`94`	`+ if (TypeUtil.isDomain(checkType, project) \|\| TypeUtil.isEntity(checkType, project) \|\| TypeUtil.isDataType(checkType, project)) {`
`95`	`95`	`return null`
`96`	`96`	`}`
`97`	`97`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {`
`32`	`32`	`"ScriptParamTestDao",`
`33`	`33`	`"SqlProcessorParamTestDao",`
`34`	`34`	`"FactoryParamTestDao",`
	`35`	`+ "DataTypeParamTypeTestDao",`
`35`	`36`	`)`
`36`	`37`	`private val daoPackage = "inspection/paramtype"`
`37`	`38`
`@@ -43,6 +44,7 @@ class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {`
`43`	`44`	`addOtherJavaFile("collector", "HogeCollector.java")`
`44`	`45`	`addOtherJavaFile("function", "HogeFunction.java")`
`45`	`46`	`addOtherJavaFile("function", "HogeBiFunction.java")`
	`47`	`+ addOtherJavaFile("domain", "Salary.java")`
`46`	`48`	`testDaoNames.forEach { daoName ->`
`47`	`49`	`addDaoJavaFile("$daoPackage/$daoName.java")`
`48`	`50`	`}`
`@@ -87,4 +89,9 @@ class AnnotationParamTypeCheckInspectionTest : DomaSqlTest() {`
`87`	`89`	`val dao = findDaoClass("$daoPackage.FactoryParamTestDao")`
`88`	`90`	`myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)`
`89`	`91`	`}`
	`92`	`+`
	`93`	`+ fun testDataTypeParam() {`
	`94`	`+ val dao = findDaoClass("$daoPackage.DataTypeParamTypeTestDao")`
	`95`	`+ myFixture.testHighlighting(false, false, false, dao.containingFile.virtualFile)`
	`96`	`+ }`
`90`	`97`	`}`