Merge pull request #29130 from sreenath-tm

* pr/29130:
  Polish "Adapt FieldHint to recent GraalVM versions"
  Adapt FieldHint to recent GraalVM versions

Closes gh-29130

Author: snicoll

spring-beans/src/test/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanRegistrationAotContributionTests.java

@@ -73,7 +73,7 @@ void contributeWhenPrivateFieldInjectionInjectsUsingReflection() {
 		RegisteredBean registeredBean = getAndApplyContribution(
 				PrivateFieldInjectionSample.class);
 		assertThat(RuntimeHintsPredicates.reflection()
-				.onField(PrivateFieldInjectionSample.class, "environment").withWriteMode())
+				.onField(PrivateFieldInjectionSample.class, "environment"))
 				.accepts(this.generationContext.getRuntimeHints());
 		compile(registeredBean, (postProcessor, compiled) -> {
 			PrivateFieldInjectionSample instance = new PrivateFieldInjectionSample();
@@ -92,7 +92,7 @@ void contributeWhenPackagePrivateFieldInjectionInjectsUsingConsumer() {
 		RegisteredBean registeredBean = getAndApplyContribution(
 				PackagePrivateFieldInjectionSample.class);
 		assertThat(RuntimeHintsPredicates.reflection()
-				.onField(PackagePrivateFieldInjectionSample.class, "environment").withWriteMode())
+				.onField(PackagePrivateFieldInjectionSample.class, "environment"))
 				.accepts(this.generationContext.getRuntimeHints());
 		compile(registeredBean, (postProcessor, compiled) -> {
 			PackagePrivateFieldInjectionSample instance = new PackagePrivateFieldInjectionSample();

spring-core-test/src/main/java/org/springframework/aot/agent/InstrumentedMethod.java

@@ -290,7 +290,7 @@ enum InstrumentedMethod {
 	 * {@link Field#set(Object, Object)}.
 	 */
 	FIELD_SET(Field.class, "set", HintType.REFLECTION,
-			invocation -> reflection().onField(invocation.getInstance()).withWriteMode()),
+			invocation -> reflection().onField(invocation.getInstance())),
 
 
 	/*

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

@@ -17,10 +17,6 @@
 package org.springframework.aot.hint;
 
 import java.lang.reflect.Field;
-import java.util.function.Consumer;
-
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
 
 /**
  * A hint that describes the need for reflection on a {@link Field}.
@@ -30,115 +26,8 @@
  */
 public final class FieldHint extends MemberHint {
 
-	private final FieldMode mode;
-
-	private final boolean allowUnsafeAccess;
-
-
-	private FieldHint(Builder builder) {
-		super(builder.name);
-		this.mode = (builder.mode != null ? builder.mode : FieldMode.WRITE);
-		this.allowUnsafeAccess = builder.allowUnsafeAccess;
-	}
-
-	/**
-	 * Return whether setting the value of the field should be allowed.
-	 * @return {@code true} to allow {@link Field#set(Object, Object)}.
-	 * @deprecated in favor of {@link #getMode()}
-	 */
-	@Deprecated
-	public boolean isAllowWrite() {
-		return this.mode == FieldMode.WRITE;
-	}
-
-	/**
-	 * Return the {@linkplain FieldMode mode} that applies to this hint.
-	 * @return the mode
-	 */
-	public FieldMode getMode() {
-		return this.mode;
-	}
-
-	/**
-	 * Return whether using {@code Unsafe} on the field should be allowed.
-	 * @return {@code true} to allow unsafe access
-	 */
-	public boolean isAllowUnsafeAccess() {
-		return this.allowUnsafeAccess;
-	}
-
-	/**
-	 * Return a {@link Consumer} that applies the given {@link FieldMode}
-	 * to the accepted {@link Builder}.
-	 * @param mode the mode to apply
-	 * @return a consumer to apply the mode
-	 */
-	public static Consumer<Builder> builtWith(FieldMode mode) {
-		return builder -> builder.withMode(mode);
+	FieldHint(String name) {
+		super(name);
 	}
 
-
-	/**
-	 * Builder for {@link FieldHint}.
-	 */
-	public static class Builder {
-
-		private final String name;
-
-		@Nullable
-		private FieldMode mode;
-
-		private boolean allowUnsafeAccess;
-
-
-		Builder(String name) {
-			this.name = name;
-		}
-
-		/**
-		 * Specify if setting the value of the field should be allowed.
-		 * @param allowWrite {@code true} to allow {@link Field#set(Object, Object)}
-		 * @return {@code this}, to facilitate method chaining
-		 * @deprecated in favor of {@link #withMode(FieldMode)}
-		 */
-		@Deprecated
-		public Builder allowWrite(boolean allowWrite) {
-			if (allowWrite) {
-				return withMode(FieldMode.WRITE);
-			}
-			return this;
-		}
-
-		/**
-		 * Specify that the {@linkplain FieldMode mode} is required.
-		 * @param mode the required mode
-		 * @return {@code this}, to facilitate method chaining
-		 */
-		public Builder withMode(FieldMode mode) {
-			Assert.notNull(mode, "'mode' must not be null");
-			if ((this.mode == null || !this.mode.includes(mode))) {
-				this.mode = mode;
-			}
-			return this;
-		}
-
-		/**
-		 * Specify whether using {@code Unsafe} on the field should be allowed.
-		 * @param allowUnsafeAccess {@code true} to allow unsafe access
-		 * @return {@code this}, to facilitate method chaining
-		 */
-		public Builder allowUnsafeAccess(boolean allowUnsafeAccess) {
-			this.allowUnsafeAccess = allowUnsafeAccess;
-			return this;
-		}
-
-		/**
-		 * Create a {@link FieldHint} based on the state of this builder.
-		 * @return a field hint
-		 */
-		FieldHint build() {
-			return new FieldHint(this);
-		}
-
-	}
 }

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

@@ -147,35 +147,14 @@ public ReflectionHints registerTypes(Iterable<TypeReference> types, Consumer<Typ
 		return this;
 	}
 
-	/**
-	 * Register the need for reflection on the specified {@link Field},
-	 * enabling {@link FieldMode#WRITE}.
-	 * @param field the field that requires reflection
-	 * @return {@code this}, to facilitate method chaining
-	 */
-	public ReflectionHints registerField(Field field) {
-		return registerField(field, FieldMode.WRITE);
-	}
-
-	/**
-	 * Register the need for reflection on the specified {@link Field}
-	 * using the specified {@link FieldMode}.
-	 * @param field the field that requires reflection
-	 * @return {@code this}, to facilitate method chaining
-	 */
-	public ReflectionHints registerField(Field field, FieldMode mode) {
-		return registerField(field, FieldHint.builtWith(mode));
-	}
-
 	/**
 	 * Register the need for reflection on the specified {@link Field}.
 	 * @param field the field that requires reflection
-	 * @param fieldHint a builder to further customize the hints of this field
 	 * @return {@code this}, to facilitate method chaining
 	 */
-	public ReflectionHints registerField(Field field, Consumer<FieldHint.Builder> fieldHint) {
+	public ReflectionHints registerField(Field field) {
 		return registerType(TypeReference.of(field.getDeclaringClass()),
-				typeHint -> typeHint.withField(field.getName(), fieldHint));
+				typeHint -> typeHint.withField(field.getName()));
 	}
 
 	/**

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

@@ -57,7 +57,7 @@ private TypeHint(Builder builder) {
 		this.type = builder.type;
 		this.reachableType = builder.reachableType;
 		this.memberCategories = Set.copyOf(builder.memberCategories);
-		this.fields = builder.fields.values().stream().map(FieldHint.Builder::build).collect(Collectors.toSet());
+		this.fields = builder.fields.stream().map(FieldHint::new).collect(Collectors.toSet());
 		this.constructors = builder.constructors.values().stream().map(ExecutableHint.Builder::build).collect(Collectors.toSet());
 		this.methods = builder.methods.values().stream().map(ExecutableHint.Builder::build).collect(Collectors.toSet());
 	}
@@ -147,7 +147,7 @@ public static class Builder {
 		@Nullable
 		private TypeReference reachableType;
 
-		private final Map<String, FieldHint.Builder> fields = new HashMap<>();
+		private final Set<String> fields = new HashSet<>();
 
 		private final Map<ExecutableKey, ExecutableHint.Builder> constructors = new HashMap<>();
 
@@ -184,36 +184,13 @@ public Builder onReachableType(Class<?> reachableType) {
 			return this;
 		}
 
-		/**
-		 * Register the need for reflection on the field with the specified name,
-		 * enabling write access.
-		 * @param name the name of the field
-		 * @return {@code this}, to facilitate method chaining
-		 */
-		public Builder withField(String name) {
-			return withField(name, FieldMode.WRITE);
-		}
-
-		/**
-		 * Register the need for reflection on the field with the specified name
-		 * using the specified {@link FieldMode}.
-		 * @param name the name of the field
-		 * @param mode the requested mode
-		 * @return {@code this}, to facilitate method chaining
-		 */
-		public Builder withField(String name, FieldMode mode) {
-			return withField(name, FieldHint.builtWith(mode));
-		}
-
 		/**
 		 * Register the need for reflection on the field with the specified name.
 		 * @param name the name of the field
-		 * @param fieldHint a builder to further customize the hints of this field
 		 * @return {@code this}, to facilitate method chaining
 		 */
-		public Builder withField(String name, Consumer<FieldHint.Builder> fieldHint) {
-			FieldHint.Builder builder = this.fields.computeIfAbsent(name, FieldHint.Builder::new);
-			fieldHint.accept(builder);
+		public Builder withField(String name) {
+			this.fields.add(name);
 			return this;
 		}
 

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

@@ -28,8 +28,6 @@
 
 import org.springframework.aot.hint.ExecutableHint;
 import org.springframework.aot.hint.ExecutableMode;
-import org.springframework.aot.hint.FieldHint;
-import org.springframework.aot.hint.FieldMode;
 import org.springframework.aot.hint.MemberCategory;
 import org.springframework.aot.hint.ReflectionHints;
 import org.springframework.aot.hint.RuntimeHints;
@@ -375,57 +373,10 @@ public static class FieldHintPredicate implements Predicate<RuntimeHints> {
 
 		private final Field field;
 
-		private FieldMode mode = FieldMode.READ;
-
-		private boolean allowUnsafeAccess;
-
 		FieldHintPredicate(Field field) {
 			this.field = field;
 		}
 
-		/**
-		 * Refine the current predicate to match if write access is allowed on the field.
-		 * @return the refined {@link RuntimeHints} predicate
-		 * @see FieldHint#isAllowWrite()
-		 * @deprecated in favor of {@link #withReadMode()} or {@link #withWriteMode()}
-		 */
-		@Deprecated
-		public FieldHintPredicate allowWrite() {
-			this.mode = FieldMode.WRITE;
-			return this;
-		}
-
-		/**
-		 * Refine the current predicate to match if read access is allowed on the field.
-		 * @return the refined {@link RuntimeHints} predicate
-		 * @see FieldHint#getMode()
-		 */
-		public FieldHintPredicate withReadMode() {
-			// FieldMode.READ is already the default and should not override a writeMode() call.
-			return this;
-		}
-
-		/**
-		 * Refine the current predicate to match if write access is allowed on the field.
-		 * @return the refined {@link RuntimeHints} predicate
-		 * @see FieldHint#getMode()
-		 */
-		public FieldHintPredicate withWriteMode() {
-			this.mode = FieldMode.WRITE;
-			return this;
-		}
-
-
-		/**
-		 * Refine the current predicate to match if unsafe access is allowed on the field.
-		 * @return the refined {@link RuntimeHints} predicate
-		 * @see FieldHint#isAllowUnsafeAccess() ()
-		 */
-		public FieldHintPredicate allowUnsafeAccess() {
-			this.allowUnsafeAccess = true;
-			return this;
-		}
-
 		@Override
 		public boolean test(RuntimeHints runtimeHints) {
 			TypeHint typeHint = runtimeHints.reflection().getTypeHint(this.field.getDeclaringClass());
@@ -447,9 +398,7 @@ private boolean memberCategoryMatch(TypeHint typeHint) {
 
 		private boolean exactMatch(TypeHint typeHint) {
 			return typeHint.fields().anyMatch(fieldHint ->
-					this.field.getName().equals(fieldHint.getName())
-							&& (fieldHint.getMode().includes(this.mode))
-							&& (!this.allowUnsafeAccess || this.allowUnsafeAccess == fieldHint.isAllowUnsafeAccess()));
+					this.field.getName().equals(fieldHint.getName()));
 		}
 	}