Fix type argument annotation inheritance

micronaut-projects · Oct 17, 2023 · 15a5ff0 · 15a5ff0
1 parent bad548c
commit 15a5ff0
Show file tree

Hide file tree

Showing 2 changed files with 96 additions and 9 deletions.
diff --git a/validation-processor/src/main/java/io/micronaut/validation/visitor/ValidationVisitor.java b/validation-processor/src/main/java/io/micronaut/validation/visitor/ValidationVisitor.java
@@ -21,20 +21,15 @@
 import io.micronaut.core.annotation.Introspected;
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.annotation.Vetoed;
-import io.micronaut.inject.ast.ClassElement;
-import io.micronaut.inject.ast.ConstructorElement;
-import io.micronaut.inject.ast.FieldElement;
-import io.micronaut.inject.ast.MethodElement;
-import io.micronaut.inject.ast.ParameterElement;
-import io.micronaut.inject.ast.TypedElement;
+import io.micronaut.inject.ast.*;
 import io.micronaut.inject.ast.annotation.MutableAnnotationMetadataDelegate;
 import io.micronaut.inject.processing.ProcessingException;
 import io.micronaut.inject.validation.RequiresValidation;
 import io.micronaut.inject.visitor.TypeElementVisitor;
 import io.micronaut.inject.visitor.VisitorContext;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.*;
+import java.util.stream.Stream;
 
 /**
  * The visitor creates annotations utilized by the Validator.
@@ -78,7 +73,6 @@ public void visitClass(ClassElement element, VisitorContext context) {
             classElement.annotate(Introspected.class);
         }
         classElement.getMethods().forEach(m -> visitMethod(m, context));
-//        classElement.getFields().forEach(f -> visitField(f, context));
     }
 
     @Override
@@ -105,6 +99,9 @@ public void visitMethod(MethodElement element, VisitorContext context) {
         if (!visited.add(element)) {
             return;
         }
+
+        getOverriddenMethods(element).forEach(m -> inheritAnnotationsForMethod(element, m));
+
         boolean isPrivate = element.isPrivate();
         boolean isAbstract = element.getOwningType().isInterface() || element.getOwningType().isAbstract();
         boolean requireOnConstraint = isAbstract || !isPrivate;
@@ -182,4 +179,62 @@ private boolean visitTypedElementValidationAndMarkForValidationIfNeeded(TypedEle
         }
         return requires;
     }
+
+    /**
+     * Method that makes sure that all the annotations are inherited from parent.
+     * In particular, type arguments annotations are not inherited by default.
+     */
+    private void inheritAnnotationsForMethod(MethodElement method, MethodElement parent) {
+        ParameterElement[] methodParameters = method.getParameters();
+        ParameterElement[] parentParameters = parent.getParameters();
+
+        for (int i = 0; i < methodParameters.length; ++i) {
+            inheritAnnotationsForParameter(methodParameters[i], parentParameters[i]);
+        }
+    }
+
+    /**
+     * Method that makes sure that all the annotations are inherited from parent.
+     * In particular, type arguments annotations are not inherited by default.
+     */
+    private void inheritAnnotationsForParameter(TypedElement element, TypedElement parentElement) {
+        if (element.getType().equals(parentElement.getType())) {
+            Stream<String> parentAnnotations = Stream.concat(
+                    parentElement.getAnnotationNamesByStereotype(ANN_CONSTRAINT).stream(),
+                    parentElement.getAnnotationNamesByStereotype(ANN_VALID).stream()
+            );
+            parentAnnotations
+                    .filter(name -> !element.hasAnnotation(name))
+                    .flatMap(name -> parentElement.getAnnotationValuesByName(name).stream())
+                    .forEach(element::annotate);
+
+            Map<String, ClassElement> typeArguments = element.getGenericType().getTypeArguments();
+            Map<String, ClassElement> parentTypeArguments = parentElement.getGenericType().getTypeArguments();
+            if (typeArguments.size() != parentTypeArguments.size()) {
+                return;
+            }
+            for (String parameter: typeArguments.keySet()) {
+                inheritAnnotationsForParameter(
+                        typeArguments.get(parameter),
+                        parentTypeArguments.get(parameter)
+                );
+            }
+        }
+    }
+
+    /**
+     * Get all the methods that current method overrides.
+     */
+    private Collection<MethodElement> getOverriddenMethods(MethodElement element) {
+        List<MethodElement> results = new ArrayList<>();
+        ClassElement classElement = element.getOwningType();
+        classElement.getSuperType()
+                .flatMap(t -> t.getMethods().stream().filter(element::overrides).findFirst())
+                .ifPresent(results::add);
+        classElement.getInterfaces().forEach(i ->
+                i.getMethods().stream().filter(element::overrides).findFirst().ifPresent(results::add)
+        );
+        return results;
+    }
+
 }
diff --git a/...ation-processor/src/test/groovy/io/micronaut/validation/visitor/ValidatedParseSpec.groovy b/...ation-processor/src/test/groovy/io/micronaut/validation/visitor/ValidatedParseSpec.groovy
@@ -6,6 +6,7 @@ import io.micronaut.inject.ValidatedBeanDefinition
 import io.micronaut.inject.validation.RequiresValidation
 import io.micronaut.inject.writer.BeanDefinitionVisitor
 import jakarta.validation.Valid
+import jakarta.validation.constraints.NotBlank
 
 import java.time.LocalDate
 
@@ -85,6 +86,37 @@ class Test {
         method.arguments[0].annotationMetadata.hasAnnotation("io.micronaut.validation.annotation.ValidatedElement")
     }
 
+    void "test constraints on inherited generic parameters make method @Validated"() {
+        given:
+        def definition = buildBeanDefinition('test.Test','''
+package test;
+
+import java.util.List;
+import jakarta.validation.constraints.NotBlank;
+
+@jakarta.inject.Singleton
+class Test implements TestBase {
+    @Override
+    public void setList(List<String> list) {
+    }
+}
+
+interface TestBase {
+    @io.micronaut.context.annotation.Executable
+    void setList(List<@NotBlank String> list);
+}
+''')
+        when:
+        def method = definition.getRequiredMethod("setList", List<String>);
+
+        then:
+        method.hasStereotype(VALIDATED_ANN)
+        method.arguments.size() == 1
+        method.arguments[0].annotationMetadata.hasAnnotation("io.micronaut.validation.annotation.ValidatedElement")
+        method.arguments[0].typeParameters.size() == 1
+        method.arguments[0].typeParameters[0].annotationMetadata.hasAnnotation(NotBlank)
+    }
+
     void "test constraints on a controller operation make method @Validated"() {
         given:
         def definition = buildBeanDefinition('test.Test', '''