Consistently set target type in generated code

Previously, a bean definition that is optimized AOT could have
different metadata based on whether its resolved type had a generic or
not. This is due to RootBeanDefinition taking either a Class or a
ResolvableType doing fundamentally different things. While the former
sets the bean class which is to little use with an instance supplier,
the latter specifies the target type of the bean.

This commit sets the target type of the bean, using the existing
setter methods that take either a class or a ResolvableType and set the
same attribute consistently.

Closes gh-30689

spring-beans/src/main/java/org/springframework/beans/factory/aot/DefaultBeanRegistrationCodeFragments.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -18,6 +18,7 @@ package org.springframework.beans.factory.aot;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Executable;
+import java.lang.reflect.Modifier;
 import java.util.List;
 import java.util.function.Predicate;
 
@@ -47,12 +48,6 @@ import org.springframework.util.ClassUtils;
  */
 class DefaultBeanRegistrationCodeFragments implements BeanRegistrationCodeFragments {
 
-	/**
-	 * The variable name used to hold the bean type.
-	 */
-	private static final String BEAN_TYPE_VARIABLE = "beanType";
-
-
 	private final BeanRegistrationsCode beanRegistrationsCode;
 
 	private final RegisteredBean registeredBean;
@@ -118,19 +113,45 @@ class DefaultBeanRegistrationCodeFragments implements BeanRegistrationCodeFragme
 			ResolvableType beanType, BeanRegistrationCode beanRegistrationCode) {
 
 		CodeBlock.Builder code = CodeBlock.builder();
-		code.addStatement(generateBeanTypeCode(beanType));
+		RootBeanDefinition mergedBeanDefinition = this.registeredBean.getMergedBeanDefinition();
+		Class<?> beanClass = (mergedBeanDefinition.hasBeanClass()
+				? ClassUtils.getUserClass(mergedBeanDefinition.getBeanClass()) : null);
+		CodeBlock beanClassCode = generateBeanClassCode(
+				beanRegistrationCode.getClassName().packageName(), beanClass);
 		code.addStatement("$T $L = new $T($L)", RootBeanDefinition.class,
-				BEAN_DEFINITION_VARIABLE, RootBeanDefinition.class, BEAN_TYPE_VARIABLE);
+				BEAN_DEFINITION_VARIABLE, RootBeanDefinition.class, beanClassCode);
+		if (targetTypeNecessary(beanType, beanClass)) {
+			code.addStatement("$L.setTargetType($L)", BEAN_DEFINITION_VARIABLE,
+					generateBeanTypeCode(beanType));
+		}
 		return code.build();
 	}
 
+	private CodeBlock generateBeanClassCode(String targetPackage, @Nullable Class<?> beanClass) {
+		if (beanClass != null) {
+			if (Modifier.isPublic(beanClass.getModifiers()) || targetPackage.equals(beanClass.getPackageName())) {
+				return CodeBlock.of("$T.class", beanClass);
+			}
+			else {
+				return CodeBlock.of("$S", beanClass.getName());
+			}
+		}
+		return CodeBlock.of("");
+	}
+
 	private CodeBlock generateBeanTypeCode(ResolvableType beanType) {
 		if (!beanType.hasGenerics()) {
-			return CodeBlock.of("$T<?> $L = $T.class", Class.class, BEAN_TYPE_VARIABLE,
-					ClassUtils.getUserClass(beanType.toClass()));
+			return CodeBlock.of("$T.class", ClassUtils.getUserClass(beanType.toClass()));
 		}
-		return CodeBlock.of("$T $L = $L", ResolvableType.class, BEAN_TYPE_VARIABLE,
-				ResolvableTypeCodeGenerator.generateCode(beanType));
+		return ResolvableTypeCodeGenerator.generateCode(beanType);
+	}
+
+	private boolean targetTypeNecessary(ResolvableType beanType, @Nullable Class<?> beanClass) {
+		if (beanType.hasGenerics() || beanClass == null) {
+			return true;
+		}
+		return (!beanType.toClass().equals(beanClass)
+				|| this.registeredBean.getMergedBeanDefinition().getFactoryMethodName() != null);
 	}
 
 	@Override