Consider nested generics in TypeDiscoverer equality comparison.

We now compare nested generics wrapped into TypeInformation to consider type equality for deeply parametrized types.

Previously, we resolved type parameters to Class so Foo<List<String>> was considered equal to Foo<List<Map>> as the type parameter of the first nesting level was erased.

Closes #3051

Author: mp911de

src/main/java/org/springframework/data/util/TypeDiscoverer.java

@@ -60,6 +60,8 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
 	private final Map<Constructor<?>, List<TypeInformation<?>>> constructorParameters = new ConcurrentHashMap<>();
 	private final Lazy<List<TypeInformation<?>>> typeArguments;
 
+	private final Lazy<List<TypeInformation<?>>> resolvedGenerics;
+
 	protected TypeDiscoverer(ResolvableType type) {
 
 		Assert.notNull(type, "Type must not be null");
@@ -68,6 +70,10 @@ protected TypeDiscoverer(ResolvableType type) {
 		this.componentType = Lazy.of(this::doGetComponentType);
 		this.valueType = Lazy.of(this::doGetMapValueType);
 		this.typeArguments = Lazy.of(this::doGetTypeArguments);
+		this.resolvedGenerics = Lazy.of(() -> Arrays.stream(resolvableType.getGenerics()) //
+				.map(TypeInformation::of) // use TypeInformation comparison to remove any attachments to variableResolver
+																	// holding the type source
+				.collect(Collectors.toList()));
 	}
 
 	static TypeDiscoverer<?> td(ResolvableType type) {
@@ -325,15 +331,7 @@ public boolean equals(@Nullable Object o) {
 			return false;
 		}
 
-		var collect1 = Arrays.stream(resolvableType.getGenerics()) //
-				.map(ResolvableType::toClass) //
-				.collect(Collectors.toList());
-
-		var collect2 = Arrays.stream(that.resolvableType.getGenerics()) //
-				.map(ResolvableType::toClass) //
-				.collect(Collectors.toList());
-
-		return ObjectUtils.nullSafeEquals(collect1, collect2);
+		return ObjectUtils.nullSafeEquals(resolvedGenerics.get(), that.resolvedGenerics.get());
 	}
 
 	@Override

src/test/java/org/springframework/data/util/TypeDiscovererUnitTests.java

@@ -29,6 +29,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
+
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.core.ResolvableType;
 import org.springframework.data.geo.GeoResults;
@@ -348,6 +349,15 @@ void differentEqualsAndHashCodeForTypeDiscovererAndClassTypeInformation() {
 		assertThat(discoverer.hashCode()).isNotEqualTo(classTypeInformation.hashCode());
 	}
 
+	@Test // GH-3051
+	void considersNestedGenericsInEquality() throws ReflectiveOperationException {
+
+		ResolvableType containerList = ResolvableType.forField(WithContainer.class.getDeclaredField("containerList"));
+		ResolvableType containerMap = ResolvableType.forField(WithContainer.class.getDeclaredField("containerMap"));
+
+		assertThat(TypeInformation.of(containerList)).isNotEqualTo(TypeInformation.of(containerMap));
+	}
+
 	class Person {
 
 		Addresses addresses;
@@ -441,4 +451,15 @@ class EnumMapWrapper {
 	class GeoResultsWrapper {
 		GeoResults<Leaf> results;
 	}
+
+	static class WithContainer {
+		MyContainer<List<String>> containerList;
+
+		MyContainer<List<Map<Long, Double>>> containerMap;
+	}
+
+	static class MyContainer<T> {
+		T data;
+	}
+
 }