Allow only properties defined within the Entity class; treat properties from non-Entity parent classes as errors.

Author: xterao

src/main/kotlin/org/domaframework/doma/intellij/common/psi/PsiPatternUtil.kt

@@ -157,7 +157,7 @@ object PsiPatternUtil {
         targetType: IElementType?,
     ): MutableList<PsiElement> {
         var prevElement = PsiTreeUtil.prevLeaf(element, true)
-        var prevElements = mutableListOf<PsiElement>()
+        val prevElements = mutableListOf<PsiElement>()
         while (prevElement != null &&
             prevElement !is PsiWhiteSpace &&
             prevElement.elementType != targetType &&

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

@@ -76,30 +76,20 @@ object TypeUtil {
         type: PsiType?,
         project: Project,
     ): Boolean {
-        var clazz = type?.let { project.getJavaClazz(type) }
-        while (clazz != null) {
-            if (clazz.isEntity()) {
-                return true
-            }
-            clazz = clazz.superClass
-        }
-        return false
+        val clazz = type?.let { project.getJavaClazz(type) }
+        return clazz?.isEntity() == true
     }
 
     fun isImmutableEntity(
         project: Project,
         canonicalText: String,
     ): Boolean {
-        var returnTypeClass = project.getJavaClazz(canonicalText)
-        while (returnTypeClass != null) {
-            val entity = returnTypeClass.getClassAnnotation(DomaClassName.ENTITY.className)
-            if (entity != null) {
-                return AnnotationUtil.getBooleanAttributeValue(entity, "immutable") == true ||
-                    returnTypeClass.isRecord
-            }
-            returnTypeClass = returnTypeClass.superClass
-        }
-        return false
+        val returnTypeClass = project.getJavaClazz(canonicalText)
+        val entity =
+            returnTypeClass?.getClassAnnotation(DomaClassName.ENTITY.className) ?: return false
+        return entity.let { entity ->
+            AnnotationUtil.getBooleanAttributeValue(entity, "immutable") == true
+        } || returnTypeClass.isRecord
     }
 
     /**

src/main/kotlin/org/domaframework/doma/intellij/inspection/dao/processor/option/DaoAnnotationOptionParameterCheckProcessor.kt

@@ -112,10 +112,8 @@ class DaoAnnotationOptionParameterCheckProcessor(
             var searchParamClass: PsiClass? = project.getJavaClazz(searchParamType)
 
             valueFields.forEachIndexed { _, field ->
-                val currentField =
-                    searchParamClass
-                        ?.allFields
-                        ?.find { property -> isOptionTargetProperty(property, field, project) }
+                // Error when specifying a property not defined in the Entity or the Embeddable.
+                val currentField = getMatchFields(searchParamClass).find { f -> isOptionTargetProperty(f, field, project) }
                 // Given that the first `searchParamType` is assumed to contain the type of  Entity class,
                 // checking the index for a primitive type is unnecessary.
                 if (searchParamType is PsiPrimitiveType) {
@@ -168,16 +166,20 @@ class DaoAnnotationOptionParameterCheckProcessor(
                 .filter { it is PsiLiteralExpression }
         }
 
+    private fun getMatchFields(paramClass: PsiClass?):List<PsiField> =
+        paramClass?.allFields?.filter { f ->
+        val parentClass = f.parent as? PsiClass
+            (parentClass?.isEntity() == true ||  parentClass?.isEmbeddable() == true)
+                    && (TypeUtil.isBaseOrOptionalWrapper(f.type) || TypeUtil.isEmbeddable(f.type, project))
+                 } ?: emptyList()
+
     private fun getTargetOptionProperties(paramClass: PsiClass?) =
-        paramClass?.allFields?.filter { isOptionTargetProperty(it, it.name, project) }?.joinToString(", ") { it.name.substringAfter(":") }
-            ?: "No fields found"
+        getMatchFields(paramClass).joinToString(", ") { it.name.substringAfter(":") }
 
-    private fun getEmbeddableProperties(embeddableClass: PsiClass?) =
-        embeddableClass
-            ?.allFields
-            ?.filter { !TypeUtil.isEntity(it.type, project) && !TypeUtil.isEmbeddable(it.type, project) }
-            ?.joinToString(", ") { it.name }
-            ?: "No properties found"
+    /**
+     * If the last field access is Embeddable, get its property list
+     */
+    private fun getEmbeddableProperties(embeddableClass: PsiClass?) = getMatchFields(embeddableClass).joinToString(", ") { it.name }
 
     private fun isOptionTargetProperty(
         field: PsiField,
@@ -186,7 +188,7 @@ class DaoAnnotationOptionParameterCheckProcessor(
     ): Boolean =
         (
             field.name == optionPropertyName && (
-                !TypeUtil.isEntity(field.type, project) ||
+                TypeUtil.isBaseOrOptionalWrapper(field.type) ||
                     TypeUtil.isEmbeddable(field.type, project)
             )
         )

src/test/kotlin/org/domaframework/doma/intellij/inspection/dao/AnnotationOptionParameterInspectionTest.kt

@@ -33,7 +33,7 @@ class AnnotationOptionParameterInspectionTest : DomaSqlTest() {
      * - Error check when specifying fields not defined in the parameter type with `exclude` option.
      * - Error check for specifying fields not defined in immutable Entity with `MultiInsert` (also for fields not defined in parameter type).
      * - Error check for specifying fields not defined in mutable Entity with `MultiInsert`.
-     * - Error check for specifying fields not defined in parameter type with batch annotations.
+     * - Error check for specifying fields not defined in the parameter type with batch annotations.
      * - Error when ending with an embedded property.
      * - Error when specifying incorrect properties in an embedded class.
      * - Error check for invalid field specification in `Returning` option.
@@ -42,5 +42,6 @@ class AnnotationOptionParameterInspectionTest : DomaSqlTest() {
      * - Error when specifying further properties from a primitive type.
      * - Error check for specifying parent class properties in subclass with `@Entity`.
      * - Error check for specifying parent class properties in subclass without `@Entity`.
+     * - Error check for specifying fields from a parent class that is not an Entity.
      */
 }

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

@@ -1,9 +1,9 @@
 package doma.example.dao.inspection.option;
 
 import doma.example.entity.Department;
-import doma.example.entity.NonSubEntity;
+import doma.example.entity.DepartmentHasNonEmmbedable;
+import doma.example.entity.FacetEntity;
 import doma.example.entity.Pckt;
-import doma.example.entity.SubEntity;
 import org.seasar.doma.*;
 import org.seasar.doma.jdbc.MultiResult;
 
@@ -125,4 +125,21 @@ public interface AnnotationOptionTestInValidDao {
      */
     @Insert(exclude = "subId.get")
     int insertPrimitiveProperty(Department department);
+
+    /**
+     * Case specifying properties defined in an intermediate non-Entity class (Entity subclass)
+     *
+     * @param subEntity
+     * @return
+     */
+    @Insert(exclude = "subName")
+    int insertReferenceNonEntityProperty2(FacetEntity subEntity);
+
+    /**
+     * Case specifying properties defined in a parent Embeddable class
+     * Error occurs first on Entity side for non-Embeddable property
+     * */
+    @Update(include = "embeddableEntity.childEmbedded3.subAccountNumber")
+    int updateReferenceParentEmbeddableProperty(DepartmentHasNonEmmbedable department);
+
 }

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

@@ -0,0 +1,23 @@
+package doma.example.entity;
+
+import doma.example.domain.ClientUser;
+import doma.example.domain.ClientUserHasNonEmbeddable;
+import org.seasar.doma.Column;
+import org.seasar.doma.Entity;
+
+/** Entity class with Embeddable property */
+@Entity
+public class DepartmentHasNonEmmbedable {
+  public Integer id;
+  public String name;
+
+  @Column(updatable = false)
+  public String location;
+
+  public Integer managerCount;
+
+  int subId;
+
+  public ClientUserHasNonEmbeddable embeddableEntity;
+
+}

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

@@ -0,0 +1,15 @@
+package doma.example.entity;
+
+import org.seasar.doma.Entity;
+
+/**
+ * Entity class at the lowest layer of the inheritance hierarchy
+ * {@code FoundationEntity}->{@code LayerNonEntity}->{@code FacetNonEntity}
+ */
+@Entity
+public class FacetEntity extends LayerNonEntity {
+
+	public Integer firstId;
+	public String firstName;
+	public String lastName;
+}

src/test/testData/src/main/java/doma/example/entity/ParentEntity.java renamed to src/test/testData/src/main/java/doma/example/entity/FoundationEntity.java

@@ -3,8 +3,12 @@
 import org.seasar.doma.Entity;
 import org.seasar.doma.Id;
 
+/**
+ * Entity class at the top of the inheritance hierarchy
+ * {@code FoundationEntity}
+ */
 @Entity
-public class ParentEntity {
+public class FoundationEntity {
 
 	@Id
 	Integer id;

src/test/testData/src/main/java/doma/example/entity/SubEntity.java renamed to src/test/testData/src/main/java/doma/example/entity/LayerEntity.java

@@ -3,10 +3,13 @@
 import org.seasar.doma.Entity;
 import org.seasar.doma.Table;
 
-/** Class with @Entity on both itself and parent */
+/**
+ * Entity class in the middle of the inheritance hierarchy
+ * {@code FoundationEntity}->{@code LayerEntity}
+ */
 @Entity
 @Table(name = "sub_entity_1")
-public class SubEntity extends ParentEntity {
+public class LayerEntity extends FoundationEntity {
   Integer amount;
 
   String subName;

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

@@ -0,0 +1,17 @@
+package doma.example.entity;
+
+import org.seasar.doma.Table;
+
+/**
+ * Non-Entity class in the middle of the inheritance hierarchy
+ * {@code FoundationEntity}->{@code LayerNonEntity}
+ * Cannot be used with include/exclude options
+ * Cannot be specified as a parameter for certain annotation type DAO methods
+ */
+@Table(name = "sub_entity_2")
+public class LayerNonEntity extends FoundationEntity {
+
+	Integer amount;
+
+	String subName;
+}