Modify existing code inspection test cases

Author: xterao

src/test/kotlin/org/domaframework/doma/intellij/complate/sql/SqlCompleteTest.kt

@@ -109,10 +109,10 @@ class SqlCompleteTest : DomaSqlTest() {
             listOf(
                 "elseif",
                 "else",
-                "end",
-                "expand",
             ),
             listOf(
+                "end",
+                "expand",
                 "employee",
                 "if",
                 "populate",

src/test/kotlin/org/domaframework/doma/intellij/reference/SqlReferenceTestCase.kt

@@ -15,17 +15,23 @@
  */
 package org.domaframework.doma.intellij.reference
 
+import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.psi.util.elementType
 import org.domaframework.doma.intellij.DomaSqlTest
 import org.domaframework.doma.intellij.psi.SqlCustomElExpr
+import org.domaframework.doma.intellij.psi.SqlElClass
+import org.domaframework.doma.intellij.psi.SqlElIdExpr
+import org.domaframework.doma.intellij.psi.SqlTypes
 import org.jetbrains.kotlin.idea.core.util.toPsiFile
 
 class SqlReferenceTestCase : DomaSqlTest() {
     val testPackage = "reference"
     val testDaoName = "ReferenceTestDao"
 
     val forItemResolve = "SqlElIdExprImpl(EL_ID_EXPR)"
+    val forItemFieldAccessResolve = "SqlElFieldAccessExprImpl(EL_FIELD_ACCESS_EXPR)"
     val daoParameterResolve = "PsiParameter"
     val fieldResolve = "PsiField"
     val methodResolve = "PsiMethod"
@@ -37,17 +43,19 @@ class SqlReferenceTestCase : DomaSqlTest() {
         addSqlFile("$testPackage/$testDaoName/referenceDaoParameter.sql")
         addSqlFile("$testPackage/$testDaoName/referenceEntityProperty.sql")
         addSqlFile("$testPackage/$testDaoName/referenceStaticField.sql")
+        addSqlFile("$testPackage/$testDaoName/referenceListFieldMethod.sql")
+        addSqlFile("$testPackage/$testDaoName/referenceForItem.sql")
     }
 
     fun testReferenceDaoMethodParameter() {
         referenceTest(
             "referenceDaoParameter",
             mapOf(
-                "reportId" to "$daoParameterResolve:reportId",
-                "tableName" to "$daoParameterResolve:tableName",
-                "columns" to "$daoParameterResolve:columns",
-                "column" to forItemResolve,
-                "notExistParam" to null,
+                "reportId" to listOf("$daoParameterResolve:reportId"),
+                "tableName" to listOf("$daoParameterResolve:tableName"),
+                "columns" to listOf("$daoParameterResolve:columns"),
+                "column" to listOf(forItemResolve),
+                "notExistParam" to listOf(null),
             ),
         )
     }
@@ -56,13 +64,13 @@ class SqlReferenceTestCase : DomaSqlTest() {
         referenceTest(
             "referenceEntityProperty",
             mapOf(
-                "detail" to "$daoParameterResolve:detail",
-                "getFirstEmployee" to "$methodResolve:getFirstEmployee",
-                "projectNumber" to "$fieldResolve:projectNumber",
-                "projects" to "$daoParameterResolve:projects",
-                "project" to forItemResolve,
-                "id" to forItemResolve,
-                "employeeId" to "$fieldResolve:employeeId",
+                "detail" to listOf("$daoParameterResolve:detail"),
+                "getFirstEmployee" to listOf("$methodResolve:getFirstEmployee"),
+                "projectNumber" to listOf("$fieldResolve:projectNumber"),
+                "projects" to listOf("$daoParameterResolve:projects"),
+                "project" to listOf(forItemResolve),
+                "id" to listOf(null),
+                "employeeId" to listOf("$fieldResolve:employeeId"),
             ),
         )
     }
@@ -71,19 +79,56 @@ class SqlReferenceTestCase : DomaSqlTest() {
         referenceTest(
             "referenceStaticField",
             mapOf(
-                "doma.example.entity.ProjectDetail" to "$classResolve:ProjectDetail",
-                "doma.example.entity.Project" to "$classResolve:Project",
-                "projectCategory" to "$fieldResolve:projectCategory",
-                "getTermNumber" to "$methodResolve:getTermNumber",
-                "getFirstEmployee" to "$methodResolve:getFirstEmployee",
-                "employeeId" to "$fieldResolve:employeeId",
+                "doma.example.entity.ProjectDetail" to listOf("$classResolve:ProjectDetail"),
+                "doma.example.entity.Project" to listOf("$classResolve:Project"),
+                "projectCategory" to listOf("$fieldResolve:projectCategory"),
+                "getTermNumber" to listOf("$methodResolve:getTermNumber"),
+                "getFirstEmployee" to listOf("$methodResolve:getFirstEmployee"),
+                "employeeId" to listOf("$fieldResolve:employeeId"),
+            ),
+        )
+    }
+
+    fun testReferenceListFieldMethod() {
+        referenceTest(
+            "referenceListFieldMethod",
+            mapOf(
+                "doma.example.entity.Employee" to listOf("$classResolve:Employee"),
+                "projects" to listOf("$fieldResolve:projects"),
+                "get" to listOf("$methodResolve:get"),
+                "employeesList" to listOf("$daoParameterResolve:employeesList"),
+                "projectCategory" to listOf("$fieldResolve:projectCategory"),
+                "projectNumber" to listOf("$fieldResolve:projectNumber"),
+                "0" to listOf(null),
+            ),
+        )
+    }
+
+    fun testReferenceForItem() {
+        referenceTest(
+            "referenceForItem",
+            mapOf(
+                "employeesList" to listOf("$daoParameterResolve:employeesList"),
+                "projects" to listOf("$fieldResolve:projects"),
+                "get" to listOf("$methodResolve:get"),
+                "employees" to listOf(forItemResolve),
+                "employees_has_next" to listOf(forItemResolve),
+                "employee_has_next" to listOf(forItemResolve),
+                "employee" to listOf(forItemResolve),
+                "project" to listOf(forItemResolve, forItemFieldAccessResolve),
+                "projectCategory" to listOf("$fieldResolve:projectCategory"),
+                "projectNumber" to listOf("$fieldResolve:projectNumber"),
+                "projectId" to listOf("$fieldResolve:projectId"),
+                "0" to listOf(null),
+                "\"OR\"" to listOf(null),
+                "\"AND\"" to listOf(null),
             ),
         )
     }
 
     private fun referenceTest(
         sqlFileName: String,
-        resolveExpects: Map<String, String?>,
+        resolveExpects: Map<String, List<String?>>,
     ) {
         val sqlFile = findSqlFile("$testPackage/$testDaoName/$sqlFileName.sql")
         assertNotNull("Not Found SQL File", sqlFile)
@@ -101,17 +146,36 @@ class SqlReferenceTestCase : DomaSqlTest() {
     /**
      * Resolve references in the test file.
      * sqlFile: The SQL file to resolve references in.
-     * resolveExpects: A map of expected results for each reference. Type:resolveName
+     * resolveExpects: A map of expected results for each reference. Type: List of resolveName
      */
     private fun resolveReferencesInTestFile(
         sqlFile: PsiFile,
-        resolveExpects: Map<String, String?>,
+        resolveExpects: Map<String, List<String?>>,
     ) {
-        val references = PsiTreeUtil.collectElementsOfType(sqlFile, SqlCustomElExpr::class.java)
+        val references =
+            PsiTreeUtil.collectElementsOfType(sqlFile, SqlCustomElExpr::class.java).filter {
+                !isLiteral(it) &&
+                    !(
+                        it is SqlElIdExpr &&
+                            PsiTreeUtil.getParentOfType(
+                                it,
+                                SqlElClass::class.java,
+                            ) != null
+                    )
+            }
         for (reference in references) {
             val resolveResult = reference.references.firstOrNull()?.resolve()
-            val result = resolveExpects[reference.text]
-            assertEquals(result, resolveResult?.toString())
+            val expectedResults = resolveExpects[reference.text]
+
+            println("Reference: ${reference.text}, Resolve Result: ${resolveResult?.toString()}, Expected Results: $expectedResults")
+            assertTrue(expectedResults?.contains(resolveResult?.toString()) == true)
         }
     }
+
+    private fun isLiteral(element: PsiElement): Boolean =
+        element.elementType == SqlTypes.EL_STRING ||
+            element.elementType == SqlTypes.EL_CHAR ||
+            element.elementType == SqlTypes.EL_NUMBER ||
+            element.elementType == SqlTypes.EL_NULL ||
+            element.elementType == SqlTypes.BOOLEAN
 }

src/test/testData/src/main/java/doma/example/dao/reference/ReferenceTestDao.java

@@ -16,4 +16,10 @@ public interface ReferenceTestDao {
   @Select
   ProjectDetail referenceStaticField();
 
+  @Select
+  List<Employee> referenceListFieldMethod(List<Employee> employeesList);
+
+  @Select
+  List<Employee> referenceForItem(List<List<List<Employee>>> employeesList);
+
 }

src/test/testData/src/main/java/doma/example/entity/Employee.java

@@ -1,5 +1,6 @@
 package doma.example.entity;
 
+import java.util.List;
 import java.time.LocalDate;
 import org.seasar.doma.Entity;
 import org.seasar.doma.Id;
@@ -13,7 +14,7 @@ public class Employee extends User {
   public String employeeName;
   private String department;
   private String rank;
-  public  List<Project> projects;
+  public static  List<Project> projects;
 
   public Integer managerId;
 

src/test/testData/src/main/java/doma/example/entity/Project.java

@@ -19,9 +19,9 @@ public class Project {
   public static Integr projectNumber;
   private static String projectCategory;
 
-  public static Interer cost;
+  public static Integer cost;
 
-  public Employee getFirstEmployee() {
+  public static Employee getFirstEmployee() {
     return employees.get(0);
   }
 

src/test/testData/src/main/resources/META-INF/doma/example/dao/EmployeeSummaryDao/accessStaticProperty.sql

@@ -26,7 +26,7 @@ where
     AND (
     -- static method call
     /*%for member : @doma.example.entity.ProjectDetail@members*/
-    /*%if member.hasNext() */
+    /*%if member_has_next */
       pd.member_id = /* member.employeeId */0
       /*# "OR"*/
     /*%end */

src/test/testData/src/main/resources/META-INF/doma/example/dao/EmployeeSummaryDao/bindVariableForNonEntityClass.sql

@@ -26,7 +26,8 @@
         /*%end*/
         -- Reference error for a non-existent field
         /*%for child : employee.<error descr="The field or method [projectIds] does not exist in the class [EmployeeSummary]">projectIds</error> */
-           AND pe.parent_project = /* child.projectId */0
+           -- An error occurred because the referenced element was not correctly defined.
+           AND pe.parent_project = /* <error descr="The bind variable [child] does not exist in the Dao method [bindVariableForNonEntityClass]">child</error>.projectId */0
            -- Reference error for a non-existent method
           AND pe.member_id IN /* employee.<error descr="The field or method [getTopProject] does not exist in the class [EmployeeSummary]">getTopProject</error>() */(0,1,2)
         /*%end */

src/test/testData/src/main/resources/META-INF/doma/example/dao/EmployeeSummaryDao/resolveDaoArgumentOfListType.sql

@@ -14,7 +14,7 @@
    /*%if employees.size() > 0 */
      where
      /*%for member : employees */
-        p.employee_id = /* member.employee_id */0
+        p.employee_id = /* member.<error descr="The field or method [employee_id] does not exist in the class [Employee]">employee_id</error> */0
      /*%end */
    -- Cannot be used as a class inside List-type
    /*%elseif employees.<error descr="The field or method [rank] does not exist in the class [List]">rank</error> > 3*/

src/test/testData/src/main/resources/META-INF/doma/example/dao/SqlCompleteTestDao/completeComparisonOperator.sql

@@ -5,6 +5,6 @@ select
 from employee e
  inner join project p on e.employee_id = p.employee_id
 where e.employee_id = /* summary.employeeId */1
-/*%if @doma.example.entity.Project@rank == summary.employee.<caret>r  */
+/*%if @doma.example.entity.Project@rank == summary.employee.<caret>ran  */
  and e.project_cost >= /* @doma.example.entity.Project@cost */9999
 /*%end */

src/test/testData/src/main/resources/META-INF/doma/example/dao/SqlCompleteTestDao/completeConcatenationOperator.sql

@@ -1,4 +1,4 @@
 insert into employee (id, name, rank) values (
 /* employee.employeeId */1,
 /* employee.employeeName */'name',
-/* 1 + point + employee.<caret>r */1)
+/* 1 + point + employee.<caret>ran */1)