Fix type argument annotation inheritance

validation-processor/src/main/java/io/micronaut/validation/visitor/ValidationVisitor.java

@@ -33,8 +33,13 @@
 import io.micronaut.inject.visitor.TypeElementVisitor;
 import io.micronaut.inject.visitor.VisitorContext;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Stream;
 
 /**
  * The visitor creates annotations utilized by the Validator.
@@ -78,7 +83,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 +109,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 +189,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;
+    }
+
 }

validation-processor/src/test/groovy/io/micronaut/validation/visitor/ValidatedParseSpec.groovy

@@ -2,10 +2,7 @@ package io.micronaut.validation
 
 import io.micronaut.annotation.processing.test.AbstractTypeElementSpec
 import io.micronaut.inject.BeanDefinition
-import io.micronaut.inject.ValidatedBeanDefinition
-import io.micronaut.inject.validation.RequiresValidation
 import io.micronaut.inject.writer.BeanDefinitionVisitor
-import jakarta.validation.Valid
 
 import java.time.LocalDate
 

validation-processor/src/test/groovy/io/micronaut/validation/visitor/ValidatedTypeArgumentInheritanceSpec.groovy

@@ -0,0 +1,111 @@
+package io.micronaut.validation.visitor
+
+import io.micronaut.annotation.processing.test.AbstractTypeElementSpec
+import jakarta.validation.constraints.NotBlank
+import jakarta.validation.constraints.NotNull
+import jakarta.validation.constraints.Size
+
+class ValidatedTypeArgumentInheritanceSpec extends AbstractTypeElementSpec {
+    final static String VALIDATED_ANN = "io.micronaut.validation.Validated";
+
+    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 inherited generic parameters make method @Validated deep"() {
+        given:
+        def definition = buildBeanDefinition('test.Test','''
+package test;
+
+import java.util.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+@jakarta.inject.Singleton
+class Test implements TestBase {
+    @Override
+    public void map(Map<@NotBlank String, List<@NotNull String>> list) {
+    }
+}
+
+interface TestBase {
+    @io.micronaut.context.annotation.Executable
+    void map(Map<String, List<@NotBlank String>> list);
+}
+''')
+        when:
+        def method = definition.getRequiredMethod("map", Map<String, 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() == 2
+        method.arguments[0].typeParameters[0].annotationMetadata.hasAnnotation(NotBlank)
+        method.arguments[0].typeParameters[1].typeParameters.length == 1
+        method.arguments[0].typeParameters[1].typeParameters[0].annotationMetadata.hasAnnotation(NotBlank)
+        method.arguments[0].typeParameters[1].typeParameters[0].annotationMetadata.hasAnnotation(NotNull)
+    }
+
+    void "test constraints from inherited class generic parameters make method @Validated"() {
+        given:
+        def definition = buildBeanDefinition('test.Test','''
+package test;
+
+import java.util.*;
+import jakarta.validation.constraints.Size;
+
+@jakarta.inject.Singleton
+class Test extends AbstractTest {
+    @Override
+    public void map(Map<String, @Size(min=2) String> value) {
+    }
+}
+
+abstract class AbstractTest {
+    void map(Map<String, @Size(min=2) String> value) {
+
+    }
+}
+''')
+        when:
+        def method = definition.getRequiredMethod("map", Map<String, 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() == 2
+        var anns = method.arguments[0].typeParameters[1].annotationMetadata.getAnnotationValuesByType(Size)
+        anns.size() == 1
+        anns.get(0).intValue("min").get() == 2
+    }
+
+}