Add RuntimeHints predicates generator

The `RuntimeHints` API allows to describe hints for the reflection,
proxies and resources behavior at runtime. The need for a particular
behavior can be covered by several types of hints, at different levels.
This knowledge can be important in several cases:

* before contributing additional hints, infrastructure can check if an
  existing hint already covers the behavior
* this can be used in test suites and test infrastructure

This commit adds a new RuntimeHintsPredicates that generates `Predicate`
instances for testing `RuntimeHints` against a desired runtime behavior
for reflection, resources or proxies.

Closes gh-28555

Author: bclozel

spring-beans/src/test/java/org/springframework/beans/factory/aot/BeanDefinitionPropertiesCodeGeneratorTests.java

@@ -28,8 +28,8 @@
 import org.junit.jupiter.api.Test;
 
 import org.springframework.aot.generate.GeneratedMethods;
-import org.springframework.aot.hint.ExecutableMode;
 import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsPredicates;
 import org.springframework.aot.test.generator.compile.Compiled;
 import org.springframework.aot.test.generator.compile.TestCompiler;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -277,15 +277,8 @@ void setDestroyMethodWhenMultipleDestroyMethods() {
 	}
 
 	private void assertHasMethodInvokeHints(Class<?> beanType, String... methodNames) {
-		assertThat(this.hints.reflection().getTypeHint(beanType)).satisfies(typeHint -> {
-			for (String methodName : methodNames) {
-				assertThat(typeHint.methods()).anySatisfy(methodHint -> {
-					assertThat(methodHint.getName()).isEqualTo(methodName);
-					assertThat(methodHint.getModes())
-							.containsExactly(ExecutableMode.INVOKE);
-				});
-			}
-		});
+		assertThat(methodNames).allMatch(methodName ->
+				RuntimeHintsPredicates.reflection().onMethod(beanType, methodName).invoke().test(this.hints));
 	}
 
 	@Test

spring-context/src/test/java/org/springframework/context/aot/ReflectiveProcessorBeanRegistrationAotProcessorTests.java

@@ -29,6 +29,7 @@
 import org.springframework.aot.generate.InMemoryGeneratedFiles;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.RuntimeHints;
+import org.springframework.aot.hint.RuntimeHintsPredicates;
 import org.springframework.aot.hint.TypeReference;
 import org.springframework.aot.hint.annotation.Reflective;
 import org.springframework.beans.factory.aot.BeanRegistrationAotContribution;
@@ -96,20 +97,16 @@ void shouldProcessAnnotationOnMethod() {
 	void shouldRegisterAnnotation() {
 		process(SampleMethodMetaAnnotatedBean.class);
 		RuntimeHints runtimeHints = this.generationContext.getRuntimeHints();
-		assertThat(runtimeHints.reflection().getTypeHint(SampleInvoker.class)).satisfies(typeHint ->
-				assertThat(typeHint.getMemberCategories()).containsOnly(MemberCategory.INVOKE_DECLARED_METHODS));
+		assertThat(RuntimeHintsPredicates.reflection().onType(SampleInvoker.class).withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(runtimeHints);
 		assertThat(runtimeHints.proxies().jdkProxies()).isEmpty();
 	}
 
 	@Test
 	void shouldRegisterAnnotationAndProxyWithAliasFor() {
 		process(SampleMethodMetaAnnotatedBeanWithAlias.class);
 		RuntimeHints runtimeHints = this.generationContext.getRuntimeHints();
-		assertThat(runtimeHints.reflection().getTypeHint(RetryInvoker.class)).satisfies(typeHint ->
-				assertThat(typeHint.getMemberCategories()).containsOnly(MemberCategory.INVOKE_DECLARED_METHODS));
-		assertThat(runtimeHints.proxies().jdkProxies()).anySatisfy(jdkProxyHint ->
-				assertThat(jdkProxyHint.getProxiedInterfaces()).containsExactly(
-						TypeReference.of(RetryInvoker.class), TypeReference.of(SynthesizedAnnotation.class)));
+		assertThat(RuntimeHintsPredicates.reflection().onType(RetryInvoker.class).withMemberCategory(MemberCategory.INVOKE_DECLARED_METHODS)).accepts(runtimeHints);
+		assertThat(RuntimeHintsPredicates.proxies().forInterfaces(RetryInvoker.class, SynthesizedAnnotation.class)).accepts(runtimeHints);
 	}
 
 	@Nullable
@@ -196,7 +193,7 @@ void notManaged() {
 
 	}
 
-	@Target({ ElementType.METHOD, ElementType.ANNOTATION_TYPE })
+	@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
 	@Retention(RetentionPolicy.RUNTIME)
 	@Documented
 	@Reflective
@@ -206,7 +203,7 @@ void notManaged() {
 
 	}
 
-	@Target({ ElementType.METHOD })
+	@Target({ElementType.METHOD})
 	@Retention(RetentionPolicy.RUNTIME)
 	@Documented
 	@SampleInvoker

spring-core/src/main/java/org/springframework/aot/hint/ProxyHintsPredicates.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aot.hint;
+
+import java.util.Arrays;
+import java.util.function.Predicate;
+
+import org.springframework.util.Assert;
+
+/**
+ * Generator of {@link ProxyHints} predicates, testing whether the given hints
+ * match the expected behavior for proxies.
+ * @author Brian Clozel
+ * @since 6.0
+ */
+public class ProxyHintsPredicates {
+
+	ProxyHintsPredicates() {
+	}
+
+	/**
+	 * Return a predicate that checks whether a {@link org.springframework.aot.hint.JdkProxyHint}
+	 * is registered for the given interfaces.
+	 * <p>Note that the order in which interfaces are given matters.
+	 * @param interfaces the proxied interfaces
+	 * @return the {@link RuntimeHints} predicate
+	 * @see java.lang.reflect.Proxy
+	 */
+	public Predicate<RuntimeHints> forInterfaces(Class<?>... interfaces) {
+		Assert.notEmpty(interfaces, "'interfaces' should not be empty");
+		return forInterfaces(Arrays.stream(interfaces).map(TypeReference::of).toArray(TypeReference[]::new));
+	}
+
+	/**
+	 * Return a predicate that checks whether a {@link org.springframework.aot.hint.JdkProxyHint}
+	 * is registered for the given interfaces.
+	 * <p>Note that the order in which interfaces are given matters.
+	 * @param interfaces the proxied interfaces as type references
+	 * @return the {@link RuntimeHints} predicate
+	 * @see java.lang.reflect.Proxy
+	 */
+	public Predicate<RuntimeHints> forInterfaces(TypeReference... interfaces) {
+		Assert.notEmpty(interfaces, "'interfaces' should not be empty");
+		return hints -> hints.proxies().jdkProxies().anyMatch(proxyHint ->
+				proxyHint.getProxiedInterfaces().equals(Arrays.asList(interfaces)));
+	}
+}