Skip runtime hint registration for validation constraint with missing dependencies

spring-context/src/main/java/org/springframework/validation/beanvalidation/BeanValidationBeanRegistrationAotProcessor.java

@@ -43,6 +43,7 @@
 import org.springframework.beans.factory.aot.BeanRegistrationAotContribution;
 import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor;
 import org.springframework.beans.factory.aot.BeanRegistrationCode;
+import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.support.RegisteredBean;
 import org.springframework.core.KotlinDetector;
 import org.springframework.core.ResolvableType;
@@ -98,7 +99,7 @@ private static Validator getValidatorIfAvailable() {
 
 		@Nullable
 		public static BeanRegistrationAotContribution processAheadOfTime(RegisteredBean registeredBean) {
-			if (validator == null) {
+			if (validator == null || BeanDefinition.ROLE_INFRASTRUCTURE == registeredBean.getMergedBeanDefinition().getRole()) {
 				return null;
 			}
 
@@ -127,18 +128,19 @@ private static void processAheadOfTime(Class<?> clazz, Set<Class<?>> visitedClas
 			try {
 				descriptor = validator.getConstraintsForClass(clazz);
 			}
-			catch (RuntimeException ex) {
+			catch (RuntimeException | LinkageError ex) {
+				String className = clazz.getName();
 				if (KotlinDetector.isKotlinType(clazz) && ex instanceof ArrayIndexOutOfBoundsException) {
 					// See https://hibernate.atlassian.net/browse/HV-1796 and https://youtrack.jetbrains.com/issue/KT-40857
-					logger.warn("Skipping validation constraint hint inference for class " + clazz +
+					logger.warn("Skipping validation constraint hint inference for class " + className +
 							" due to an ArrayIndexOutOfBoundsException at validator level");
 				}
 				else if (ex instanceof TypeNotPresentException) {
 					logger.debug("Skipping validation constraint hint inference for class " +
-							clazz + " due to a TypeNotPresentException at validator level: " + ex.getMessage());
+							className + " due to a TypeNotPresentException at validator level: " + ex.getMessage());
 				}
 				else {
-					logger.warn("Skipping validation constraint hint inference for class " + clazz, ex);
+					logger.warn("Skipping validation constraint hint inference for class " + className, ex);
 				}
 				return;
 			}

spring-context/src/test/java/org/springframework/validation/beanvalidation/BeanValidationBeanRegistrationAotProcessorTests.java

@@ -41,9 +41,10 @@
 import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;
 import org.springframework.aot.test.generate.TestGenerationContext;
 import org.springframework.beans.factory.aot.BeanRegistrationAotContribution;
+import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.RegisteredBean;
-import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.core.OverridingClassLoader;
 import org.springframework.lang.Nullable;
 
 import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
@@ -55,6 +56,9 @@
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
+import static org.springframework.beans.factory.config.BeanDefinition.ROLE_APPLICATION;
+import static org.springframework.beans.factory.config.BeanDefinition.ROLE_INFRASTRUCTURE;
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
 
 /**
  * Tests for {@link BeanValidationBeanRegistrationAotProcessor}.
@@ -134,17 +138,36 @@ void shouldProcessRecursiveGenericsWithoutInfiniteRecursion(Class<?> beanClass)
 				.withMemberCategory(MemberCategory.DECLARED_FIELDS)).accepts(this.generationContext.getRuntimeHints());
 	}
 
+	@Test  // gh-33940
+	void shouldSkipConstraintWithMissingDependency() throws Exception {
+		FilteringClassLoader classLoader = new FilteringClassLoader(getClass().getClassLoader());
+		Class<?> beanClass = classLoader.loadClass(ConstraintWithMissingDependency.class.getName());
+		process(beanClass);
+		assertThat(this.generationContext.getRuntimeHints().reflection().typeHints()).isEmpty();
+	}
+
+	@Test  // gh-33940
+	void shouldSkipInfrastructureBean() {
+		process(EmptyClass.class, ROLE_INFRASTRUCTURE);
+		assertThat(this.generationContext.getRuntimeHints().reflection().typeHints()).isEmpty();
+	}
+
 	private void process(Class<?> beanClass) {
-		BeanRegistrationAotContribution contribution = createContribution(beanClass);
+		process(beanClass, ROLE_APPLICATION);
+	}
+
+	private void process(Class<?> beanClass, int role) {
+		BeanRegistrationAotContribution contribution = createContribution(beanClass, role);
 		if (contribution != null) {
 			contribution.applyTo(this.generationContext, mock());
 		}
 	}
 
 	@Nullable
-	private BeanRegistrationAotContribution createContribution(Class<?> beanClass) {
+	private BeanRegistrationAotContribution createContribution(Class<?> beanClass, int role) {
 		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
-		beanFactory.registerBeanDefinition(beanClass.getName(), new RootBeanDefinition(beanClass));
+		BeanDefinition beanDefinition = rootBeanDefinition(beanClass).setRole(role).getBeanDefinition();
+		beanFactory.registerBeanDefinition(beanClass.getName(), beanDefinition);
 		return this.processor.processAheadOfTime(RegisteredBean.of(beanFactory, beanClass.getName()));
 	}
 
@@ -269,4 +292,31 @@ static class BeanWithRecursiveOptional {
 		Optional<BeanWithRecursiveOptional> optional;
 	}
 
+	static class ConstraintWithMissingDependency {
+
+		private final Filtered filtered = new Filtered();
+	}
+
+	static class Filtered {}
+
+	static class FilteringClassLoader extends OverridingClassLoader {
+
+		FilteringClassLoader(ClassLoader parent) {
+			super(parent);
+		}
+
+		@Override
+		protected boolean isEligibleForOverriding(String className) {
+			return className.startsWith(BeanValidationBeanRegistrationAotProcessorTests.class.getName());
+		}
+
+		@Override
+		protected Class<?> loadClassForOverriding(String name) throws ClassNotFoundException {
+			if (name.contains("Filtered")) {
+				throw new NoClassDefFoundError(name);
+			}
+			return super.loadClassForOverriding(name);
+		}
+	}
+
 }