Add validation for duplicate and unreachable property paths

Author: nakamura-to

doma-core/src/main/java/org/seasar/doma/message/Message.java

@@ -996,6 +996,7 @@ public enum Message implements MessageResource {
   DOMA4487("An element annotated with @AggregateStrategy must not extend other interfaces."),
   DOMA4488(
       "To specify propertyPath=\"{0}\", a separate definition of @AssociationLinker(propertyPath=\"{1}\") is required."),
+  DOMA4489("The property path \"{0}\" is duplicated in another @AssociationLinker."),
 
   // other
   DOMA5001(

doma-processor/src/main/java/org/seasar/doma/internal/apt/meta/entity/AggregateStrategyMetaFactory.java

@@ -16,6 +16,7 @@
 package org.seasar.doma.internal.apt.meta.entity;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -81,11 +82,26 @@ public AggregateStrategyMeta createTypeElementMeta(TypeElement typeElement) {
         findAssociationLinkerMetas(typeElement, root);
     validateAllPropertyPaths(associationLinkerMetas);
     validateAllTableAliases(aggregateStrategyAnnot.getTableAliasValue(), associationLinkerMetas);
+    validateAssociationNavigation(root, associationLinkerMetas);
     return new AggregateStrategyMeta(
         root, aggregateStrategyAnnot.getTableAliasValue(), associationLinkerMetas);
   }
 
   private void validateAllPropertyPaths(List<AssociationLinkerMeta> associationLinkerMetas) {
+    // validate uniqueness
+    Set<String> seen = new HashSet<>(associationLinkerMetas.size());
+    for (AssociationLinkerMeta linkerMeta : associationLinkerMetas) {
+      if (!seen.add(linkerMeta.propertyPath())) {
+        throw new AptException(
+            Message.DOMA4489,
+            linkerMeta.filedElement(),
+            linkerMeta.associationLinkerAnnot().getAnnotationMirror(),
+            linkerMeta.associationLinkerAnnot().getPropertyPath(),
+            new Object[] {linkerMeta.propertyPath()});
+      }
+    }
+
+    // validate navigation
     Map<String, AssociationLinkerMeta> map =
         associationLinkerMetas.stream()
             .collect(Collectors.toMap(AssociationLinkerMeta::propertyPath, Function.identity()));
@@ -110,7 +126,38 @@ private void validateAllTableAliases(
     for (AssociationLinkerMeta linkerMeta : associationLinkerMetas) {
       if (!seen.add(linkerMeta.tableAlias())) {
         throw new AptException(
-            Message.DOMA4481, linkerMeta.filedElement(), new Object[] {linkerMeta.tableAlias()});
+            Message.DOMA4481,
+            linkerMeta.filedElement(),
+            linkerMeta.associationLinkerAnnot().getAnnotationMirror(),
+            linkerMeta.associationLinkerAnnot().getTableAlias(),
+            new Object[] {linkerMeta.tableAlias()});
+      }
+    }
+  }
+
+  private void validateAssociationNavigation(
+      EntityCtType root, List<AssociationLinkerMeta> associationLinkerMetas) {
+    for (AssociationLinkerMeta linkerMeta : associationLinkerMetas) {
+      TypeMirror source = root.getType();
+      TypeMirror target = root.getType();
+      for (String segment : linkerMeta.propertyPathSegments()) {
+        source = target;
+        target =
+            resolveEntity(
+                source, segment, linkerMeta.filedElement(), linkerMeta.associationLinkerAnnot());
+      }
+      BiFunctionMeta biFunctionMeta = linkerMeta.biFunctionMeta();
+      if (!ctx.getMoreTypes().isSameType(biFunctionMeta.source().getType(), source)) {
+        throw new AptException(
+            Message.DOMA4475,
+            linkerMeta.filedElement(),
+            new Object[] {biFunctionMeta.source().getType(), source});
+      }
+      if (!ctx.getMoreTypes().isSameType(biFunctionMeta.target().getType(), target)) {
+        throw new AptException(
+            Message.DOMA4476,
+            linkerMeta.filedElement(),
+            new Object[] {biFunctionMeta.target().getType(), target});
       }
     }
   }
@@ -127,7 +174,6 @@ private List<AssociationLinkerMeta> findAssociationLinkerMetas(
       }
       validateModifiers(fieldElement);
       BiFunctionMeta biFunctionMeta = createBiFunctionMeta(fieldElement);
-      validateAssociation(root, associationLinkerAnnot, biFunctionMeta, fieldElement);
       AssociationLinkerMeta associationLinkerMeta =
           createAssociationLinkerMeta(
               fieldElement, associationLinkerAnnot, biFunctionMeta, aggregateStrategyElement);
@@ -218,31 +264,6 @@ public EntityCtType visitEntityCtType(EntityCtType ctType, String ordinalNumber)
     return new BiFunctionMeta(source, target, result);
   }
 
-  private void validateAssociation(
-      EntityCtType root,
-      AssociationLinkerAnnot associationLinkerAnnot,
-      BiFunctionMeta biFunctionMeta,
-      VariableElement linkerElement) {
-    TypeMirror source = root.getType();
-    TypeMirror target = root.getType();
-    String[] segments = associationLinkerAnnot.getPropertyPathValue().split("\\.");
-    if (segments.length == 0) {
-      throw new AptIllegalStateException("fragments must not be empty.");
-    }
-    for (String segment : segments) {
-      source = target;
-      target = resolveEntity(source, segment, linkerElement, associationLinkerAnnot);
-    }
-    if (!ctx.getMoreTypes().isSameType(biFunctionMeta.source.getType(), source)) {
-      throw new AptException(
-          Message.DOMA4475, linkerElement, new Object[] {biFunctionMeta.source.getType(), source});
-    }
-    if (!ctx.getMoreTypes().isSameType(biFunctionMeta.target.getType(), target)) {
-      throw new AptException(
-          Message.DOMA4476, linkerElement, new Object[] {biFunctionMeta.target.getType(), target});
-    }
-  }
-
   private TypeMirror resolveEntity(
       TypeMirror typeMirror,
       String name,
@@ -303,8 +324,8 @@ private AssociationLinkerMeta createAssociationLinkerMeta(
       BiFunctionMeta biFunctionMeta,
       TypeElement aggregateStrategyElement) {
     String propertyPath = associationLinkerAnnot.getPropertyPathValue();
-    String[] segments = propertyPath.split("\\.");
-    int propertyPathDepth = segments.length;
+    List<String> propertyPathSegments = Arrays.stream(propertyPath.split("\\.")).toList();
+    int propertyPathDepth = propertyPathSegments.size();
     String ancestorPath;
     if (propertyPathDepth == 0) {
       throw new AptIllegalStateException("propertyPath=" + propertyPath);
@@ -317,13 +338,11 @@ private AssociationLinkerMeta createAssociationLinkerMeta(
         associationLinkerAnnot,
         ancestorPath,
         associationLinkerAnnot.getPropertyPathValue(),
+        propertyPathSegments,
         propertyPathDepth,
         associationLinkerAnnot.getTableAliasValue(),
-        biFunctionMeta.source,
-        biFunctionMeta.target,
+        biFunctionMeta,
         aggregateStrategyElement,
         fieldElement);
   }
-
-  private record BiFunctionMeta(EntityCtType source, EntityCtType target, EntityCtType result) {}
 }

doma-processor/src/main/java/org/seasar/doma/internal/apt/meta/entity/AssociationLinkerMeta.java

@@ -15,6 +15,7 @@
  */
 package org.seasar.doma.internal.apt.meta.entity;
 
+import java.util.List;
 import java.util.Objects;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
@@ -25,20 +26,28 @@ public record AssociationLinkerMeta(
     AssociationLinkerAnnot associationLinkerAnnot,
     String ancestorPath,
     String propertyPath,
+    List<String> propertyPathSegments,
     int propertyPathDepth,
     String tableAlias,
-    EntityCtType source,
-    EntityCtType target,
+    BiFunctionMeta biFunctionMeta,
     TypeElement classElement,
     VariableElement filedElement) {
 
   public AssociationLinkerMeta {
     Objects.requireNonNull(associationLinkerAnnot);
     Objects.requireNonNull(propertyPath);
+    Objects.requireNonNull(propertyPathSegments);
     Objects.requireNonNull(tableAlias);
-    Objects.requireNonNull(source);
-    Objects.requireNonNull(target);
+    Objects.requireNonNull(biFunctionMeta);
     Objects.requireNonNull(classElement);
     Objects.requireNonNull(filedElement);
   }
+
+  public EntityCtType source() {
+    return biFunctionMeta.source();
+  }
+
+  public EntityCtType target() {
+    return biFunctionMeta.target();
+  }
 }

doma-processor/src/main/java/org/seasar/doma/internal/apt/meta/entity/BiFunctionMeta.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright Doma 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.seasar.doma.internal.apt.meta.entity;
+
+import java.util.Objects;
+import org.seasar.doma.internal.apt.cttype.EntityCtType;
+
+public record BiFunctionMeta(EntityCtType source, EntityCtType target, EntityCtType result) {
+  public BiFunctionMeta {
+    Objects.requireNonNull(source);
+    Objects.requireNonNull(target);
+    Objects.requireNonNull(result);
+  }
+}

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/aggregate/AggregateStrategyProcessorTest.java

@@ -150,7 +150,9 @@ public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContex
           invocationContext(InvalidAssociationSource.class, Message.DOMA4475),
           invocationContext(InvalidAssociationTarget.class, Message.DOMA4476),
           invocationContext(InvalidPropertyPath.class, Message.DOMA4474),
-          invocationContext(Subtype.class, Message.DOMA4487));
+          invocationContext(Subtype.class, Message.DOMA4487),
+          invocationContext(DuplicatePropertyPath.class, Message.DOMA4489),
+          invocationContext(UnreachableAssociation.class, Message.DOMA4488));
     }
 
     private TestTemplateInvocationContext invocationContext(

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/aggregate/DuplicatePropertyPath.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright Doma 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.seasar.doma.internal.apt.processor.aggregate;
+
+import java.util.function.BiFunction;
+import org.seasar.doma.AggregateStrategy;
+import org.seasar.doma.AssociationLinker;
+
+@AggregateStrategy(root = Emp.class, tableAlias = "e")
+interface DuplicatePropertyPath {
+
+  @AssociationLinker(propertyPath = "dept", tableAlias = "d")
+  BiFunction<Emp, Dept, Emp> dept = (e, d) -> e;
+
+  @AssociationLinker(propertyPath = "dept", tableAlias = "x")
+  BiFunction<Emp, Dept, Emp> dept2 = (e, d) -> e;
+}

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/aggregate/InvalidAssociationSource.java

@@ -21,6 +21,10 @@
 
 @AggregateStrategy(root = Dept.class, tableAlias = "d")
 interface InvalidAssociationSource {
+
+  @AssociationLinker(propertyPath = "employees", tableAlias = "e")
+  BiFunction<Dept, Emp, Dept> employees = (d, e) -> null;
+
   @AssociationLinker(propertyPath = "employees.address", tableAlias = "a")
   BiFunction<Dept, Address, Dept> address = (d, a) -> null;
 }

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/aggregate/InvalidAssociationTarget.java

@@ -21,6 +21,9 @@
 
 @AggregateStrategy(root = Dept.class, tableAlias = "d")
 interface InvalidAssociationTarget {
+  @AssociationLinker(propertyPath = "employees", tableAlias = "e")
+  BiFunction<Dept, Emp, Dept> employees = (d, e) -> null;
+
   @AssociationLinker(propertyPath = "employees.address", tableAlias = "a")
   BiFunction<Emp, Dept, Emp> address = (e, d) -> null;
 }

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/aggregate/InvalidPropertyPath.java

@@ -21,6 +21,10 @@
 
 @AggregateStrategy(root = Dept.class, tableAlias = "d")
 interface InvalidPropertyPath {
+
+  @AssociationLinker(propertyPath = "employees", tableAlias = "e")
+  BiFunction<Dept, Emp, Dept> employees = (d, e) -> null;
+
   @AssociationLinker(propertyPath = "employees.unknown", tableAlias = "a")
   BiFunction<Emp, Address, Emp> address = (e, a) -> null;
 }

doma-processor/src/test/java/org/seasar/doma/internal/apt/processor/aggregate/UnreachableAssociation.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright Doma 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.seasar.doma.internal.apt.processor.aggregate;
+
+import java.util.function.BiFunction;
+import org.seasar.doma.AggregateStrategy;
+import org.seasar.doma.AssociationLinker;
+
+@AggregateStrategy(root = Dept.class, tableAlias = "d")
+interface UnreachableAssociation {
+
+  @AssociationLinker(propertyPath = "employeeList.address", tableAlias = "a")
+  BiFunction<Emp, Address, Emp> address = (e, a) -> e;
+}