Stop generating unnecessary reference to field type

This commit updates the generator to stop specifying a field type when
reflection is necessary, or when a reference to a field should be
retrieved as its name alone suffices.

This could trigger package protected issues if the field type is not
public.

See gh-28047

Author: snicoll

spring-beans/src/main/java/org/springframework/beans/factory/generator/InjectionGenerator.java

@@ -224,7 +224,7 @@ private CodeBlock generateMethodInvocation(Method injectionPoint, Consumer<Build
 
 	CodeBlock generateFieldInjection(Field injectionPoint, boolean required) {
 		Builder code = CodeBlock.builder();
-		code.add("instanceContext.field($S, $T.class", injectionPoint.getName(), injectionPoint.getType());
+		code.add("instanceContext.field($S", injectionPoint.getName());
 		code.add(")\n").indent().indent();
 		if (required) {
 			code.add(".invoke(beanFactory, (attributes) ->");
@@ -236,8 +236,8 @@ CodeBlock generateFieldInjection(Field injectionPoint, boolean required) {
 		if (hasAssignment) {
 			code.beginControlFlow("");
 			String fieldName = String.format("%sField", injectionPoint.getName());
-			code.addStatement("$T $L = $T.findField($T.class, $S, $T.class)", Field.class, fieldName, ReflectionUtils.class,
-					injectionPoint.getDeclaringClass(), injectionPoint.getName(), injectionPoint.getType());
+			code.addStatement("$T $L = $T.findField($T.class, $S)", Field.class, fieldName, ReflectionUtils.class,
+					injectionPoint.getDeclaringClass(), injectionPoint.getName());
 			code.addStatement("$T.makeAccessible($L)", ReflectionUtils.class, fieldName);
 			code.addStatement("$T.setField($L, bean, attributes.get(0))", ReflectionUtils.class, fieldName);
 			code.unindent().add("}");

spring-beans/src/main/java/org/springframework/beans/factory/generator/config/BeanDefinitionRegistrar.java

@@ -298,11 +298,10 @@ private InjectedElementResolver resolveInstanceCreator(@Nullable Executable inst
 		/**
 		 * Create an {@link InjectedElementResolver} for the specified field.
 		 * @param name the name of the field
-		 * @param type the type of the field
 		 * @return a resolved for the specified field
 		 */
-		public InjectedElementResolver field(String name, Class<?> type) {
-			return new InjectedFieldResolver(getField(name, type), this.beanName);
+		public InjectedElementResolver field(String name) {
+			return new InjectedFieldResolver(getField(name), this.beanName);
 		}
 
 		/**
@@ -315,9 +314,9 @@ public InjectedElementResolver method(String name, Class<?>... parameterTypes) {
 			return new InjectedMethodResolver(getMethod(this.beanType, name, parameterTypes), this.beanType, this.beanName);
 		}
 
-		private Field getField(String fieldName, Class<?> fieldType) {
-			Field field = ReflectionUtils.findField(this.beanType, fieldName, fieldType);
-			Assert.notNull(field, () -> "No field '" + fieldName + "' with type " + fieldType.getName() + " found on " + this.beanType);
+		private Field getField(String fieldName) {
+			Field field = ReflectionUtils.findField(this.beanType, fieldName);
+			Assert.notNull(field, () -> "No field '" + fieldName + "' found on " + this.beanType.getName());
 			return field;
 		}
 

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

@@ -44,7 +44,7 @@ class AutowiredAnnotationBeanInstantiationContributionTests {
 	void contributeWithPackageProtectedFieldInjection() {
 		CodeContribution contribution = contribute(PackageProtectedFieldInjectionSample.class);
 		assertThat(CodeSnippet.process(contribution.statements().toCodeBlock())).isEqualTo("""
-				instanceContext.field("environment", Environment.class)
+				instanceContext.field("environment")
 						.invoke(beanFactory, (attributes) -> bean.environment = attributes.get(0))""");
 		assertThat(contribution.runtimeHints().reflection().typeHints()).singleElement().satisfies(typeHint -> {
 			assertThat(typeHint.getType()).isEqualTo(TypeReference.of(PackageProtectedFieldInjectionSample.class));
@@ -62,9 +62,9 @@ void contributeWithPackageProtectedFieldInjection() {
 	void contributeWithPrivateFieldInjection() {
 		CodeContribution contribution = contribute(PrivateFieldInjectionSample.class);
 		assertThat(CodeSnippet.process(contribution.statements().toCodeBlock())).isEqualTo("""
-				instanceContext.field("environment", Environment.class)
+				instanceContext.field("environment")
 						.invoke(beanFactory, (attributes) -> {
-							Field environmentField = ReflectionUtils.findField(AutowiredAnnotationBeanInstantiationContributionTests.PrivateFieldInjectionSample.class, "environment", Environment.class);
+							Field environmentField = ReflectionUtils.findField(AutowiredAnnotationBeanInstantiationContributionTests.PrivateFieldInjectionSample.class, "environment");
 							ReflectionUtils.makeAccessible(environmentField);
 							ReflectionUtils.setField(environmentField, bean, attributes.get(0));
 						})""");
@@ -99,9 +99,9 @@ void contributeWithPublicMethodInjection() {
 	void contributeWithInjectionPoints() {
 		CodeContribution contribution = contribute(ResourceInjectionBean.class);
 		assertThat(CodeSnippet.process(contribution.statements().toCodeBlock())).isEqualTo("""
-				instanceContext.field("testBean", TestBean.class)
+				instanceContext.field("testBean")
 						.resolve(beanFactory, false).ifResolved((attributes) -> {
-							Field testBeanField = ReflectionUtils.findField(AutowiredAnnotationBeanPostProcessorTests.ResourceInjectionBean.class, "testBean", TestBean.class);
+							Field testBeanField = ReflectionUtils.findField(AutowiredAnnotationBeanPostProcessorTests.ResourceInjectionBean.class, "testBean");
 							ReflectionUtils.makeAccessible(testBeanField);
 							ReflectionUtils.setField(testBeanField, bean, attributes.get(0));
 						});

spring-beans/src/test/java/org/springframework/beans/factory/generator/InjectionGeneratorTests.java

@@ -142,25 +142,25 @@ void generateInjectionForNonRequiredMethodWithGenericParameter() {
 	void generateInjectionForRequiredField() {
 		Field field = field(SampleBean.class, "counter");
 		assertThat(generateInjection(field, true)).isEqualTo("""
-				instanceContext.field("counter", Integer.class)
+				instanceContext.field("counter")
 						.invoke(beanFactory, (attributes) -> bean.counter = attributes.get(0))""");
 	}
 
 	@Test
 	void generateInjectionForNonRequiredField() {
 		Field field = field(SampleBean.class, "counter");
 		assertThat(generateInjection(field, false)).isEqualTo("""
-				instanceContext.field("counter", Integer.class)
+				instanceContext.field("counter")
 						.resolve(beanFactory, false).ifResolved((attributes) -> bean.counter = attributes.get(0))""");
 	}
 
 	@Test
 	void generateInjectionForRequiredPrivateField() {
 		Field field = field(SampleBean.class, "source");
 		assertThat(generateInjection(field, true)).isEqualTo("""
-				instanceContext.field("source", String.class)
+				instanceContext.field("source")
 						.invoke(beanFactory, (attributes) -> {
-							Field sourceField = ReflectionUtils.findField(InjectionGeneratorTests.SampleBean.class, "source", String.class);
+							Field sourceField = ReflectionUtils.findField(InjectionGeneratorTests.SampleBean.class, "source");
 							ReflectionUtils.makeAccessible(sourceField);
 							ReflectionUtils.setField(sourceField, bean, attributes.get(0));
 						})""");

spring-beans/src/test/java/org/springframework/beans/factory/generator/config/BeanDefinitionRegistrarTests.java

@@ -257,8 +257,8 @@ void registerWithInjectedField() {
 		beanFactory.registerSingleton("environment", environment);
 		BeanDefinitionRegistrar.of("test", InjectionSample.class).instanceSupplier(instanceContext -> {
 			InjectionSample bean = new InjectionSample();
-			instanceContext.field("environment", Environment.class).invoke(beanFactory,
-					attributes -> bean.environment = (attributes.get(0)));
+			instanceContext.field("environment").invoke(beanFactory, attributes ->
+					bean.environment = (attributes.get(0)));
 			return bean;
 		}).register(beanFactory);
 		assertBeanFactory(beanFactory, () -> {
@@ -271,11 +271,10 @@ void registerWithInjectedField() {
 	void registerWithInvalidField() {
 		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
 		BeanDefinitionRegistrar.of("test", InjectionSample.class).instanceSupplier(instanceContext ->
-				instanceContext.field("doesNotExist", Object.class).resolve(beanFactory)).register(beanFactory);
+				instanceContext.field("doesNotExist").resolve(beanFactory)).register(beanFactory);
 		assertThatThrownBy(() -> beanFactory.getBean(InjectionSample.class)
-		).isInstanceOf(BeanCreationException.class)
-				.hasMessageContaining("No field '%s' with type %s found", "doesNotExist", Object.class.getName())
-				.hasMessageContaining(InjectionSample.class.getName());
+		).isInstanceOf(BeanCreationException.class).hasMessageContaining(
+				"No field 'doesNotExist' found on " + InjectionSample.class.getName());
 	}
 
 	@Test