Merge pull request #45011 from nosan

* pr/45011:
  Polish 'Handle generics with identical names in different positions'
  Handle generics with identical names in different positions

Closes gh-45011

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/main/java/org/springframework/boot/configurationprocessor/TypeUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2024 the original author or authors.
+ * Copyright 2012-2025 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.
@@ -23,7 +23,6 @@ import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -47,6 +46,7 @@ import javax.lang.model.util.Types;
  * @author Stephane Nicoll
  * @author Phillip Webb
  * @author Pavel Anisimov
+ * @author Dmytro Nosan
  */
 class TypeUtils {
 
@@ -135,7 +135,7 @@ class TypeUtils {
 		if (type == null) {
 			return null;
 		}
-		return type.accept(this.typeExtractor, createTypeDescriptor(element));
+		return type.accept(this.typeExtractor, resolveTypeDescriptor(element));
 	}
 
 	/**
@@ -218,7 +218,7 @@ class TypeUtils {
 		return WRAPPER_TO_PRIMITIVE.get(type.toString());
 	}
 
-	TypeDescriptor resolveTypeDescriptor(TypeElement element) {
+	private TypeDescriptor resolveTypeDescriptor(TypeElement element) {
 		if (this.typeDescriptors.containsKey(element)) {
 			return this.typeDescriptors.get(element);
 		}
@@ -319,22 +319,22 @@ class TypeUtils {
 		}
 
 		@Override
-		public String visitTypeVariable(TypeVariable t, TypeDescriptor descriptor) {
-			TypeMirror typeMirror = descriptor.resolveGeneric(t);
-			if (typeMirror != null) {
-				if (typeMirror instanceof TypeVariable typeVariable) {
+		public String visitTypeVariable(TypeVariable typeVariable, TypeDescriptor descriptor) {
+			TypeMirror resolvedGeneric = descriptor.resolveGeneric(typeVariable);
+			if (resolvedGeneric != null) {
+				if (resolvedGeneric instanceof TypeVariable resolveTypeVariable) {
 					// Still unresolved, let's use the upper bound, checking first if
 					// a cycle may exist
-					if (!hasCycle(typeVariable)) {
-						return visit(typeVariable.getUpperBound(), descriptor);
+					if (!hasCycle(resolveTypeVariable)) {
+						return visit(resolveTypeVariable.getUpperBound(), descriptor);
 					}
 				}
 				else {
-					return visit(typeMirror, descriptor);
+					return visit(resolvedGeneric, descriptor);
 				}
 			}
 			// Fallback to simple representation of the upper bound
-			return defaultAction(t.getUpperBound(), descriptor);
+			return defaultAction(typeVariable.getUpperBound(), descriptor);
 		}
 
 		private boolean hasCycle(TypeVariable variable) {
@@ -394,37 +394,20 @@ class TypeUtils {
 
 		private final Map<TypeVariable, TypeMirror> generics = new HashMap<>();
 
-		Map<TypeVariable, TypeMirror> getGenerics() {
-			return Collections.unmodifiableMap(this.generics);
-		}
-
 		TypeMirror resolveGeneric(TypeVariable typeVariable) {
-			return resolveGeneric(getParameterName(typeVariable));
-		}
-
-		TypeMirror resolveGeneric(String parameterName) {
-			return this.generics.entrySet()
-				.stream()
-				.filter((e) -> getParameterName(e.getKey()).equals(parameterName))
-				.findFirst()
-				.map(Entry::getValue)
-				.orElse(null);
+			TypeMirror resolved = this.generics.get(typeVariable);
+			if (resolved != typeVariable && resolved instanceof TypeVariable resolvedTypeVariable) {
+				return resolveGeneric(resolvedTypeVariable);
+			}
+			return resolved;
 		}
 
 		private void registerIfNecessary(TypeMirror variable, TypeMirror resolution) {
 			if (variable instanceof TypeVariable typeVariable) {
-				if (this.generics.keySet()
-					.stream()
-					.noneMatch((candidate) -> getParameterName(candidate).equals(getParameterName(typeVariable)))) {
-					this.generics.put(typeVariable, resolution);
-				}
+				this.generics.put(typeVariable, resolution);
 			}
 		}
 
-		private String getParameterName(TypeVariable typeVariable) {
-			return typeVariable.asElement().getSimpleName().toString();
-		}
-
 	}
 
 }

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationprocessor/TypeUtilsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2023 the original author or authors.
+ * Copyright 2012-2025 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.
@@ -17,16 +17,23 @@
 package org.springframework.boot.configurationprocessor;
 
 import java.time.Duration;
+import java.util.Map;
 import java.util.function.BiConsumer;
 
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.util.ElementFilter;
+
 import org.junit.jupiter.api.Test;
 
-import org.springframework.boot.configurationprocessor.TypeUtils.TypeDescriptor;
 import org.springframework.boot.configurationprocessor.test.RoundEnvironmentTester;
 import org.springframework.boot.configurationprocessor.test.TestableAnnotationProcessor;
 import org.springframework.boot.configurationsample.generic.AbstractGenericProperties;
 import org.springframework.boot.configurationsample.generic.AbstractIntermediateGenericProperties;
+import org.springframework.boot.configurationsample.generic.MixGenericNameProperties;
 import org.springframework.boot.configurationsample.generic.SimpleGenericProperties;
+import org.springframework.boot.configurationsample.generic.UnresolvedGenericProperties;
 import org.springframework.core.test.tools.SourceFile;
 import org.springframework.core.test.tools.TestCompiler;
 
@@ -41,40 +48,52 @@ import static org.assertj.core.api.Assertions.assertThat;
 class TypeUtilsTests {
 
 	@Test
-	void resolveTypeDescriptorOnConcreteClass() {
+	void resolveTypeOnConcreteClass() {
 		process(SimpleGenericProperties.class, (roundEnv, typeUtils) -> {
-			TypeDescriptor typeDescriptor = typeUtils
-				.resolveTypeDescriptor(roundEnv.getRootElement(SimpleGenericProperties.class));
-			assertThat(typeDescriptor.getGenerics().keySet().stream().map(Object::toString)).containsOnly("A", "B",
-					"C");
-			assertThat(typeDescriptor.resolveGeneric("A")).hasToString(String.class.getName());
-			assertThat(typeDescriptor.resolveGeneric("B")).hasToString(Integer.class.getName());
-			assertThat(typeDescriptor.resolveGeneric("C")).hasToString(Duration.class.getName());
-
+			TypeElement typeElement = roundEnv.getRootElement(SimpleGenericProperties.class);
+			assertThat(getTypeOfField(typeUtils, typeElement, "name")).hasToString(String.class.getName());
+			assertThat(getTypeOfField(typeUtils, typeElement, "mappings"))
+				.hasToString(constructMapType(Integer.class, Duration.class));
 		});
 	}
 
 	@Test
-	void resolveTypeDescriptorOnIntermediateClass() {
+	void resolveTypeOnIntermediateClass() {
 		process(AbstractIntermediateGenericProperties.class, (roundEnv, typeUtils) -> {
-			TypeDescriptor typeDescriptor = typeUtils
-				.resolveTypeDescriptor(roundEnv.getRootElement(AbstractIntermediateGenericProperties.class));
-			assertThat(typeDescriptor.getGenerics().keySet().stream().map(Object::toString)).containsOnly("A", "B",
-					"C");
-			assertThat(typeDescriptor.resolveGeneric("A")).hasToString(String.class.getName());
-			assertThat(typeDescriptor.resolveGeneric("B")).hasToString(Integer.class.getName());
-			assertThat(typeDescriptor.resolveGeneric("C")).hasToString("C");
+			TypeElement typeElement = roundEnv.getRootElement(AbstractIntermediateGenericProperties.class);
+			assertThat(getTypeOfField(typeUtils, typeElement, "name")).hasToString(String.class.getName());
+			assertThat(getTypeOfField(typeUtils, typeElement, "mappings"))
+				.hasToString(constructMapType(Integer.class, Object.class));
 		});
 	}
 
 	@Test
-	void resolveTypeDescriptorWithOnlyGenerics() {
+	void resolveTypeWithOnlyGenerics() {
 		process(AbstractGenericProperties.class, (roundEnv, typeUtils) -> {
-			TypeDescriptor typeDescriptor = typeUtils
-				.resolveTypeDescriptor(roundEnv.getRootElement(AbstractGenericProperties.class));
-			assertThat(typeDescriptor.getGenerics().keySet().stream().map(Object::toString)).containsOnly("A", "B",
-					"C");
+			TypeElement typeElement = roundEnv.getRootElement(AbstractGenericProperties.class);
+			assertThat(getTypeOfField(typeUtils, typeElement, "name")).hasToString(Object.class.getName());
+			assertThat(getTypeOfField(typeUtils, typeElement, "mappings"))
+				.hasToString(constructMapType(Object.class, Object.class));
+		});
+	}
 
+	@Test
+	void resolveTypeWithUnresolvedGenericProperties() {
+		process(UnresolvedGenericProperties.class, (roundEnv, typeUtils) -> {
+			TypeElement typeElement = roundEnv.getRootElement(UnresolvedGenericProperties.class);
+			assertThat(getTypeOfField(typeUtils, typeElement, "name")).hasToString(String.class.getName());
+			assertThat(getTypeOfField(typeUtils, typeElement, "mappings"))
+				.hasToString(constructMapType(Number.class, Object.class));
+		});
+	}
+
+	@Test
+	void resolvedTypeMixGenericNamePropertiesProperties() {
+		process(MixGenericNameProperties.class, (roundEnv, typeUtils) -> {
+			TypeElement typeElement = roundEnv.getRootElement(MixGenericNameProperties.class);
+			assertThat(getTypeOfField(typeUtils, typeElement, "name")).hasToString(String.class.getName());
+			assertThat(getTypeOfField(typeUtils, typeElement, "mappings"))
+				.hasToString(constructMapType(Number.class, Object.class));
 		});
 	}
 
@@ -87,4 +106,29 @@ class TypeUtilsTests {
 		});
 	}
 
+	private String constructMapType(Class<?> keyType, Class<?> valueType) {
+		return "%s<%s,%s>".formatted(Map.class.getName(), keyType.getName(), valueType.getName());
+	}
+
+	private String getTypeOfField(TypeUtils typeUtils, TypeElement typeElement, String name) {
+		TypeMirror field = findField(typeUtils, typeElement, name);
+		if (field == null) {
+			throw new IllegalStateException("Unable to find field '" + name + "' in " + typeElement);
+		}
+		return typeUtils.getType(typeElement, field);
+	}
+
+	private TypeMirror findField(TypeUtils typeUtils, TypeElement typeElement, String name) {
+		for (VariableElement variableElement : ElementFilter.fieldsIn(typeElement.getEnclosedElements())) {
+			if (variableElement.getSimpleName().contentEquals(name)) {
+				return variableElement.asType();
+			}
+		}
+		TypeMirror superclass = typeElement.getSuperclass();
+		if (superclass != null && !superclass.toString().equals(Object.class.getName())) {
+			return findField(typeUtils, (TypeElement) typeUtils.asElement(superclass), name);
+		}
+		return null;
+	}
+
 }

spring-boot-project/spring-boot-tools/spring-boot-configuration-processor/src/test/java/org/springframework/boot/configurationsample/generic/MixGenericNameProperties.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012-2025 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.boot.configurationsample.generic;
+
+/**
+ * Properties with unresolved generic types that use identical generic parameter names but
+ * differ in their positions.
+ *
+ * @param <C> mapping name type
+ * @param <B> mapping value type
+ * @author Dmytro Nosan
+ */
+public class MixGenericNameProperties<B, C extends Number> extends AbstractGenericProperties<String, C, B> {
+
+}