rmannibucau commented on code in PR #191:
URL: https://github.com/apache/bval/pull/191#discussion_r2098034743


##########
bval-jsr/src/main/java/org/apache/bval/cdi/BValExtension.java:
##########
@@ -132,28 +134,31 @@ public <A> void processAnnotatedType(final @Observes 
ProcessAnnotatedType<A> pat
         final int modifiers = javaClass.getModifiers();
         if (!javaClass.isInterface() && !javaClass.isAnonymousClass() && 
!Modifier.isFinal(modifiers) && !Modifier.isAbstract(modifiers)) {
             try {
-                Queue<Class<?>> toProcess = new LinkedList<>();
-                toProcess.add(annotatedType.getJavaClass());
+                Queue<AnnotatedType<?>> toProcess = new LinkedList<>();
+                toProcess.add(annotatedType);
 
                 while (!toProcess.isEmpty()) {
-                    Class<?> now = toProcess.poll();
-                    Executable[] methods = now.getMethods();
-                    Executable[] constructors = now.getConstructors();
+                    AnnotatedType<?> now = toProcess.poll();
+                    Set<? extends AnnotatedMethod<?>> methods = 
now.getMethods();
+                    Set<? extends AnnotatedConstructor<?>> constructors = 
now.getConstructors();
 
                     if (hasValidation(now)
-                            || hasValidation(methods) || 
hasValidation(constructors)
-                            || hasParamsWithValidation(methods) || 
hasParamsWithValidation(constructors)) {
+                            || methods.stream().anyMatch(this::hasValidation)
+                            || 
constructors.stream().anyMatch(this::hasValidation)
+                            || 
methods.stream().anyMatch(this::hasParamsWithValidation)
+                            || 
constructors.stream().anyMatch(this::hasParamsWithValidation)) {
                         pat.setAnnotatedType(new 
BValAnnotatedType<>(annotatedType));
-
                         break;
                     }
 
-                    // Nothing found, collect superclass/interface and repeat 
(See BVAL-222)
-                    if (now.getSuperclass() != Object.class && 
now.getSuperclass() != null) {
-                        toProcess.add(now.getSuperclass());
+                    Class<?> superclass = now.getJavaClass().getSuperclass();

Review Comment:
   maybe a compromise is to do it only for explicit methods and skip it 
intentionally for all others
   
   so something like:
   
   ```
   if (ValidateOnExecution is none on type) { return ;}
   foreach (potentiallyexecutable : type.getall()) {
     // if explicit only handle *this* method in parents - note that we cache 
parents in a lazily initialized list to not recompute it twice if not needed, 
maybe something like Map<MethodSignature, List<Executable>/*in parents only*/>)
     model = ...;
     if (ValidateOnExecution) { model = handleoverrideparent(model, 
potentiallyexecutale); }
     handleModel(model);
   }
   ```
   
   means all the totally implicit (no ValidateOnExecution) cases will be 
skipped as before, but also means the explicit cases will work as intended with 
almost no penalty



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: dev-unsubscr...@bval.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org

Reply via email to