fix: register reflection and resource hints for error handlers in native builds (#23054) (#23068)

Extract and register exception types from HasErrorParameter<E> generic
parameter for reflection. Register resource hints for ClassPathScanner
to discover error handler classes at runtime in GraalVM native images.

Fixes #23041

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: Zhe Sun <31067185+ZheSun88@users.noreply.github.com>

Author: 3 people

vaadin-spring/src/main/java/com/vaadin/flow/spring/springnative/VaadinBeanFactoryInitializationAotProcessor.java

@@ -23,7 +23,9 @@
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.function.Function;
 
+import com.vaadin.flow.internal.ReflectTools;
 import org.reflections.Reflections;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -113,7 +115,8 @@ public BeanFactoryInitializationAotContribution processAheadOfTime(
 
                 registerSubTypes(hints, reflections, Component.class);
                 registerSubTypes(hints, reflections, RouterLayout.class);
-                registerSubTypes(hints, reflections, HasErrorParameter.class);
+                registerSubTypes(hints, reflections, HasErrorParameter.class,
+                        VaadinBeanFactoryInitializationAotProcessor::getExceptionTypeFromHasErrorParameter);
                 registerSubTypes(hints, reflections, ComponentEvent.class);
                 registerSubTypes(hints, reflections, HasUrlParameter.class);
                 registerSubTypes(hints, reflections,
@@ -124,9 +127,7 @@ public BeanFactoryInitializationAotContribution processAheadOfTime(
 
     private void registerSubTypes(RuntimeHints hints, Reflections reflections,
             Class<?> cls) {
-        for (var c : getSubtypesOf(reflections, cls)) {
-            registerType(hints, c);
-        }
+        registerSubTypes(hints, reflections, cls, null);
     }
 
     private void registerSubTypes(RuntimeHints hints, Reflections reflections,
@@ -143,6 +144,29 @@ private void registerSubTypes(RuntimeHints hints, Reflections reflections,
         }
     }
 
+    private void registerSubTypes(RuntimeHints hints, Reflections reflections,
+            Class<?> cls,
+            Function<Class<?>, Set<Class<?>>> relatedTypesExtractor) {
+        for (var c : getSubtypesOf(reflections, cls)) {
+            registerType(hints, c);
+            if (relatedTypesExtractor != null) {
+                for (var related : relatedTypesExtractor.apply(c)) {
+                    registerType(hints, related);
+                }
+            }
+        }
+    }
+
+    // Visible for testing
+    static Set<Class<?>> getExceptionTypeFromHasErrorParameter(Class<?> clazz) {
+        Class<?> exceptionType = ReflectTools.getGenericInterfaceType(clazz,
+                HasErrorParameter.class);
+        if (exceptionType != null) {
+            return Set.of(exceptionType);
+        }
+        return Set.of();
+    }
+
     private static List<String> getPackagesWithRoutes(BeanFactory beanFactory) {
         List<String> packages = new ArrayList<String>();
         packages.add("com.vaadin");
@@ -255,6 +279,10 @@ private void registerType(RuntimeHints hints, Class<?> c) {
         }
         MemberCategory[] memberCategories = MemberCategory.values();
         hints.reflection().registerType(c, memberCategories);
+        // Resource hints are needed for ClassPathScanner in
+        // VaadinServletContextInitializer to discover classes at runtime
+        // in native builds (GraalVM)
+        registerResources(hints, c);
     }
 
     private static List<String> getPackages(BeanFactory beanFactory) {

vaadin-spring/src/test/java/com/vaadin/flow/spring/springnative/VaadinBeanFactoryInitializationAotProcessorTest.java

@@ -20,6 +20,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.Test;
@@ -316,6 +317,43 @@ void processAheadOfTime_hasErrorParameterSubtype_reflectionHintRegistered() {
                 .accepts(hints);
     }
 
+    @Test
+    void processAheadOfTime_hasErrorParameterSubtype_exceptionTypeReflectionHintRegistered() {
+        RuntimeHints hints = processAotForHintsWithSubtypes(
+                TestCustomExceptionView.class, HasErrorParameter.class);
+
+        assertThat(RuntimeHintsPredicates.reflection()
+                .onType(TestCustomException.class))
+                .as("Exception type from HasErrorParameter generic parameter should be registered for reflection")
+                .accepts(hints);
+    }
+
+    @Test
+    void processAheadOfTime_hasErrorParameterSubtype_resourceHintRegistered() {
+        RuntimeHints hints = processAotForHintsWithSubtypes(
+                TestErrorParameterView.class, HasErrorParameter.class);
+
+        assertThat(RuntimeHintsPredicates.resource()
+                .forResource(toClassResourcePath(TestErrorParameterView.class)))
+                .as("HasErrorParameter subtype should be registered as resource")
+                .accepts(hints);
+    }
+
+    @Test
+    void processAheadOfTime_hasErrorParameterSubtype_exceptionTypeResourceHintRegistered() {
+        RuntimeHints hints = processAotForHintsWithSubtypes(
+                TestCustomExceptionView.class, HasErrorParameter.class);
+
+        assertThat(RuntimeHintsPredicates.resource()
+                .forResource(toClassResourcePath(TestCustomException.class)))
+                .as("Exception type from HasErrorParameter generic parameter should be registered as resource")
+                .accepts(hints);
+    }
+
+    private static String toClassResourcePath(Class<?> clazz) {
+        return clazz.getName().replace('.', '/') + ".class";
+    }
+
     @Test
     void processAheadOfTime_componentEventSubtype_reflectionHintRegistered() {
         RuntimeHints hints = processAotForHintsWithSubtypes(
@@ -512,6 +550,27 @@ void getSubtypesOf_findsHasErrorParameterImplementations() {
                 .contains(TestErrorParameterView.class);
     }
 
+    @Test
+    void getExceptionTypeFromHasErrorParameter_extractsGenericType() {
+        Set<Class<?>> exceptionTypes = VaadinBeanFactoryInitializationAotProcessor
+                .getExceptionTypeFromHasErrorParameter(
+                        TestCustomExceptionView.class);
+
+        assertThat(exceptionTypes).as(
+                "Should extract exception type from HasErrorParameter implementation")
+                .containsExactly(TestCustomException.class);
+    }
+
+    @Test
+    void getExceptionTypeFromHasErrorParameter_returnsEmptyForNonHasErrorParameter() {
+        Set<Class<?>> exceptionTypes = VaadinBeanFactoryInitializationAotProcessor
+                .getExceptionTypeFromHasErrorParameter(TestRouteView.class);
+
+        assertThat(exceptionTypes)
+                .as("Should return empty set for non-HasErrorParameter class")
+                .isEmpty();
+    }
+
     @Test
     void getSubtypesOf_findsHasUrlParameterImplementations() {
         VaadinBeanFactoryInitializationAotProcessor processor = new VaadinBeanFactoryInitializationAotProcessor();
@@ -788,6 +847,25 @@ public int setErrorParameter(BeforeEnterEvent event,
         }
     }
 
+    public static class TestCustomException extends Exception {
+        public TestCustomException() {
+        }
+
+        public TestCustomException(String message) {
+            super(message);
+        }
+    }
+
+    @Tag("div")
+    public static class TestCustomExceptionView extends Component
+            implements HasErrorParameter<TestCustomException> {
+        @Override
+        public int setErrorParameter(BeforeEnterEvent event,
+                ErrorParameter<TestCustomException> parameter) {
+            return 400;
+        }
+    }
+
     @Tag("div")
     public static class TestUrlParameterView extends Component
             implements HasUrlParameter<String> {