all tests pass now

Author: christophstrobl

src/main/java/org/springframework/data/repository/query/QueryMethod.java

@@ -299,6 +299,7 @@ private static void assertReturnTypeAssignable(Method method, Set<Class<?>> type
 		Assert.notNull(method, "Method must not be null!");
 		Assert.notEmpty(types, "Types must not be null or empty!");
 
+		// TODO: to resolve generics we'd need the actual repository interface here
 		TypeInformation<?> returnType = ClassTypeInformation.fromReturnTypeOf(method);
 
 		returnType = QueryExecutionConverters.isSingleValue(returnType.getType()) //

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

@@ -43,9 +43,14 @@ public class ClassTypeInformation<S> extends NewTypeDiscoverer<S> {
 			ReferenceType.WEAK);
 
 	public static TypeInformation<?> fromReturnTypeOf(Method method) {
-		// todo open issue in FW for ResolvableType.forMethod(method)
-		return new NewTypeDiscoverer(ResolvableType.forType(method.getGenericReturnType(), ResolvableType.forClass(method.getDeclaringClass())));
+		return new NewTypeDiscoverer<>(ResolvableType.forMethodReturnType(method));
 	}
+//
+//	public static TypeInformation<?> fromReturnTypeOf(Method method, Class<?> actualType) {
+//		// todo open issue in FW for ResolvableType.forMethod(method)
+//		//return new NewTypeDiscoverer(ResolvableType.forType(method.getGenericReturnType(), ResolvableType.forClass(method.getDeclaringClass())));
+//		return new NewTypeDiscoverer<>(ResolvableType.forMethodReturnType(method, actualType));
+//	}
 
 	Class<?> type;
 
@@ -56,7 +61,6 @@ public static TypeInformation<?> fromReturnTypeOf(Method method) {
 	public static <S> ClassTypeInformation<S> from(Class<S> type) {
 
 		Assert.notNull(type, "Type must not be null!");
-		System.out.println("type: " + type);
 
 		return (ClassTypeInformation<S>) cache.computeIfAbsent(type, ClassTypeInformation::new);
 	}

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

@@ -50,6 +50,8 @@
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -145,6 +147,15 @@ private Optional<TypeInformation<?>> getPropertyInformation(String fieldname) {
 		}
 
 		return findPropertyDescriptor(rawType, fieldname).map(it -> {
+
+			if(it.getReadMethod() != null) {
+				return new NewTypeDiscoverer(ResolvableType.forMethodReturnType(it.getReadMethod(), rawType));
+//				return ClassTypeInformation.fromReturnTypeOf(it.getReadMethod());
+			}
+			if(it.getWriteMethod() != null) {
+				return new NewTypeDiscoverer(ResolvableType.forMethodParameter(it.getWriteMethod(), 0, rawType));
+			}
+
 			return new NewTypeDiscoverer(ResolvableType.forType(it.getPropertyType(), resolvableType));
 		});
 	}
@@ -377,15 +388,33 @@ public TypeInformation<?> getSuperTypeInformation(Class<?> superType) {
 		List<ResolvableType> candidates = new ArrayList<>();
 
 		ResolvableType genericSuperclass = resolvableType.getSuperType();
-		if (genericSuperclass != null) {
+		if (genericSuperclass != null && !genericSuperclass.equals(ResolvableType.NONE)) {
 			candidates.add(genericSuperclass);
 		}
 
+		// todo try raw type interfaces //
+
 		candidates.addAll(Arrays.asList(resolvableType.getInterfaces()));
 
 		for (var candidate : candidates) {
 			if (ObjectUtils.nullSafeEquals(superType, candidate.toClass())) {
-				return new NewTypeDiscoverer(candidate);
+
+				if(resolvableType.getType() instanceof Class) {
+
+					if(ObjectUtils.isEmpty(((Class)resolvableType.getType()).getTypeParameters())) {
+						Class<?>[] classes = candidate.resolveGenerics(null);
+
+						if (!Arrays.stream(classes).filter(it -> it != null).findAny().isPresent()) {
+							return new NewTypeDiscoverer<>(ResolvableType.forRawClass(superType));
+						}
+					}
+//					return new NewTypeDiscoverer<>(ResolvableType.forClassWithGenerics(candidate.toClass(), classes));
+				}
+//				return new NewTypeDiscoverer(candidate);
+//				if(ObjectUtils.isEmpty(superType.getTypeParameters())) {
+//					new NewTypeDiscoverer(ResolvableType.forRawClass(superType));
+//				}
+				return new NewTypeDiscoverer(ResolvableType.forClass(superType, getType()));
 			} else {
 				var sup = candidate.getSuperType();
 				if (sup != null && !ResolvableType.NONE.equals(sup)) {
@@ -425,7 +454,14 @@ public List<TypeInformation<?>> getTypeArguments() {
 		if (!resolvableType.hasGenerics()) {
 			return Collections.emptyList();
 		}
-		return Arrays.stream(resolvableType.getGenerics()).map(NewTypeDiscoverer::new).collect(Collectors.toList());
+
+		return Arrays.stream(resolvableType.getGenerics()).map(it -> {
+			if(it == null || ResolvableType.NONE.equals(it)) {
+				return null;
+			}
+			return new NewTypeDiscoverer<>(it);
+
+		}).collect(Collectors.toList());
 	}
 
 	@Override

src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryMetadataUnitTests.java

@@ -21,6 +21,7 @@
 import java.util.Collection;
 import java.util.Optional;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import org.springframework.data.domain.Page;
@@ -54,8 +55,9 @@ void rejectsNonRepositoryInterface() {
 	}
 
 	@Test // DATACMNS-406
+//	@Disabled("F*****!")
 	void rejectsUnparameterizedRepositoryInterface() {
-		assertThatIllegalArgumentException().isThrownBy(() -> new DefaultRepositoryMetadata(Repository.class));
+		assertThatIllegalArgumentException().isThrownBy(() -> new DefaultRepositoryMetadata(RepoWithoutArgs.class));
 	}
 
 	@Test
@@ -196,4 +198,6 @@ static interface OptionalRepository extends Repository<User, Long> {
 		// Contrived example but to make sure recursive wrapper resolution works
 		Optional<Optional<User>> findByLastname(String lastname);
 	}
+
+	interface RepoWithoutArgs extends Repository {}
 }