Retain subclass fields over masked superclass fields in TypeDiscoverer.

When a class hides a superclass field by declaring a field of the same name, property discovery overwrote the property type from the superclass field instead of retaining the declaring subclass field.
This happened because ReflectionUtils.doWithFields traverses fields from the leaf type up through its superclasses, and the field callback unconditionally put each field into the result map.
As a result, the superclass field, visited last, overwrote the entry contributed by the subclass, exposing the wrong (and potentially incompatible) property type.

We now keep the first field encountered for a given name, which is the one declared closest to the inspected type, so a hidden superclass field no longer overrides the subclass declaration.

Closes #3500
Original pull request: #3504

Author: mp911de

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

@@ -407,8 +407,11 @@ private Map<String, TypeInformation<?>> doGetProperties() {
 
 		Map<String, TypeInformation<?>> result = new HashMap<>();
 		Class<?> type = getType();
-		FieldCallback callback = field -> result.put(field.getName(),
-				TypeInformation.of(ResolvableType.forField(field, resolvableType)));
+		FieldCallback callback = field -> {
+			if (!result.containsKey(field.getName())) {
+				result.put(field.getName(), TypeInformation.of(ResolvableType.forField(field, resolvableType)));
+			}
+		};
 
 		// Inspect fields first
 		ReflectionUtils.doWithFields(type, callback);

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

@@ -379,6 +379,14 @@ void considersNestedGenericsInEqualityForRecursiveUnresolvableTypes() throws Exc
 		assertThat(domainType.isAssignableFrom(actualType)).isTrue();
 	}
 
+	@Test // GH-3500
+	void superclassFieldsDoNotHideSubclassFields() {
+
+		TypeDiscoverer<?> discoverer = TypeDiscoverer.ofCached(ResolvableType.forClass(TheOne.class));
+
+		assertThat(discoverer.getProperty("theOne").getType()).isEqualTo(String.class);
+	}
+
 	class Person {
 
 		Addresses addresses;
@@ -487,6 +495,16 @@ static abstract class SomeType<Self extends SomeType<Self>> {
 
 	}
 
+	static class SuperclassWithProperties {
+		private CharSequence theOne;
+		private String theOther;
+	}
+
+	class TheOne extends SuperclassWithProperties {
+		private String theOne;
+	}
+
+
 	@SuppressWarnings("rawtypes")
 	interface RepoWithRawGenerics extends Repository<SomeType, SomeType> {