ResolvableType.java.forRawClass(Class) supports isAssignableFrom(ResolvableType) as well

Issue: SPR-14648

Author: jhoeller

spring-core/src/main/java/org/springframework/core/ResolvableType.java

@@ -276,7 +276,7 @@ private boolean isAssignableFrom(ResolvableType other, Map<Type, Type> matchedBe
 		WildcardBounds ourBounds = WildcardBounds.get(this);
 		WildcardBounds typeBounds = WildcardBounds.get(other);
 
-		// In the from X is assignable to <? extends Number>
+		// In the form X is assignable to <? extends Number>
 		if (typeBounds != null) {
 			return (ourBounds != null && ourBounds.isSameKind(typeBounds) &&
 					ourBounds.isAssignableFrom(typeBounds.getBounds()));
@@ -937,7 +937,7 @@ public static ResolvableType forClass(Class<?> sourceClass) {
 	 * Return a {@link ResolvableType} for the specified {@link Class}, doing
 	 * assignability checks against the raw class only (analogous to
 	 * {@link Class#isAssignableFrom}, which this serves as a wrapper for.
-	 * For example: {@code ResolvableType.forClass(MyArrayList.class)}.
+	 * For example: {@code ResolvableType.forRawClass(List.class)}.
 	 * @param sourceClass the source class ({@code null} is semantically
 	 * equivalent to {@code Object.class} for typical use cases here}
 	 * @return a {@link ResolvableType} for the specified class
@@ -951,6 +951,11 @@ public static ResolvableType forRawClass(Class<?> sourceClass) {
 			public boolean isAssignableFrom(Class<?> other) {
 				return ClassUtils.isAssignable(getRawClass(), other);
 			}
+			@Override
+			public boolean isAssignableFrom(ResolvableType other) {
+				Class<?> otherClass = other.getRawClass();
+				return (otherClass != null && ClassUtils.isAssignable(getRawClass(), otherClass));
+			}
 		};
 	}
 

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -37,6 +37,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.concurrent.Callable;
@@ -1084,7 +1085,6 @@ public void isAssignableFromForArrays() throws Exception {
 
 	@Test
 	public void isAssignableFromForWildcards() throws Exception {
-
 		ResolvableType object = ResolvableType.forClass(Object.class);
 		ResolvableType charSequence = ResolvableType.forClass(CharSequence.class);
 		ResolvableType string = ResolvableType.forClass(String.class);
@@ -1287,6 +1287,15 @@ public void testSpr12701() throws Exception {
 		assertThat(((ParameterizedType) type).getActualTypeArguments()[0], is(equalTo(String.class)));
 	}
 
+	@Test
+	public void testSpr14648() throws Exception {
+		ResolvableType collectionClass = ResolvableType.forRawClass(Collection.class);
+		ResolvableType setClass = ResolvableType.forRawClass(Set.class);
+		ResolvableType fromReturnType = ResolvableType.forMethodReturnType(Methods.class.getMethod("wildcardSet"));
+		assertTrue(collectionClass.isAssignableFrom(fromReturnType));
+		assertTrue(setClass.isAssignableFrom(fromReturnType));
+	}
+
 
 	private ResolvableType testSerialization(ResolvableType type) throws Exception {
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
@@ -1385,7 +1394,7 @@ static class TypedFields extends Fields<String> {
 	}
 
 
-	static interface Methods<T> {
+	interface Methods<T> {
 
 		List<CharSequence> charSequenceReturn();
 
@@ -1398,6 +1407,8 @@ static interface Methods<T> {
 		void typedParameter(T p);
 
 		T typedReturn();
+
+		Set<?> wildcardSet();
 	}
 
 
@@ -1453,7 +1464,7 @@ static class Assignment extends AssignmentBase<Object, CharSequence, String> {
 	}
 
 
-	static interface TypedMethods extends Methods<String> {
+	interface TypedMethods extends Methods<String> {
 	}
 
 
@@ -1526,19 +1537,19 @@ public class MyCollectionSuperclassType extends MySuperclassType<Collection<Stri
 	}
 
 
-	static interface Wildcard<T extends Number> extends List<T> {
+	interface Wildcard<T extends Number> extends List<T> {
 	}
 
 
-	static interface RawExtendsWildcard extends Wildcard {
+	interface RawExtendsWildcard extends Wildcard {
 	}
 
 
-	static interface VariableNameSwitch<V, K> extends MultiValueMap<K, V> {
+	interface VariableNameSwitch<V, K> extends MultiValueMap<K, V> {
 	}
 
 
-	static interface ListOfGenericArray extends List<List<String>[]> {
+	interface ListOfGenericArray extends List<List<String>[]> {
 	}