Restore prior resolveTypeArguments behavior

Restore prior behavior of GenericTypeResolver.resolveTypeArguments to
never include null elements in the returned array.

Issue: SPR-11030

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

@@ -245,7 +245,7 @@ public abstract class GenericTypeResolver {
 		if (!type.hasGenerics()) {
 			return null;
 		}
-		return type.resolveGenerics();
+		return type.resolveGenerics(Object.class);
 	}
 
 	/**

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

@@ -480,10 +480,24 @@ public final class ResolvableType implements Serializable {
 	 * @see #resolve()
 	 */
 	public Class<?>[] resolveGenerics() {
+		return resolveGenerics(null);
+	}
+
+	/**
+	 * Convenience method that will {@link #getGenerics() get} and {@link #resolve()
+	 * resolve} generic parameters, using the specified {@code fallback} if any type
+	 * cannot be resolved.
+	 * @param fallback the fallback class to use if resolution fails (may be {@code null})
+	 * @return an array of resolved generic parameters (the resulting array will never be
+	 * {@code null}, but it may contain {@code null} elements})
+	 * @see #getGenerics()
+	 * @see #resolve()
+	 */
+	public Class<?>[] resolveGenerics(Class<?> fallback) {
 		ResolvableType[] generics = getGenerics();
 		Class<?>[] resolvedGenerics = new Class<?>[generics.length];
 		for (int i = 0; i < generics.length; i++) {
-			resolvedGenerics[i] = generics[i].resolve();
+			resolvedGenerics[i] = generics[i].resolve(fallback);
 		}
 		return resolvedGenerics;
 	}

spring-core/src/main/java/org/springframework/core/convert/support/GenericConversionService.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -29,6 +29,7 @@ import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.springframework.core.GenericTypeResolver;
+import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.ConversionException;
 import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.ConversionService;
@@ -267,8 +268,11 @@ public class GenericConversionService implements ConfigurableConversionService {
 	// internal helpers
 
 	private GenericConverter.ConvertiblePair getRequiredTypeInfo(Object converter, Class<?> genericIfc) {
-		Class<?>[] args = GenericTypeResolver.resolveTypeArguments(converter.getClass(), genericIfc);
+		ResolvableType resolvableType = ResolvableType.forClass(converter.getClass()).as(genericIfc);
-		return (args != null ? new GenericConverter.ConvertiblePair(args[0], args[1]) : null);
+		if(resolvableType.hasUnresolvableGenerics()) {
+			return null;
+		}
+		return new GenericConverter.ConvertiblePair(resolvableType.resolveGeneric(0), resolvableType.resolveGeneric(1));
 	}
 
 	private void invalidateCache() {

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

@@ -21,6 +21,7 @@ import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import org.junit.Test;
@@ -136,6 +137,12 @@ public class GenericTypeResolverTests {
 		assertThat(x, equalTo((Type) Long.class));
 	}
 
+	@Test
+	public void getGenericsCannotBeResovled() throws Exception {
+		// SPR-11030
+		Class[] resolved = GenericTypeResolver.resolveTypeArguments(List.class, Iterable.class);
+		assertThat(resolved, equalTo(new Class[] { Object.class }));
+	}
 
 	public interface MyInterfaceType<T> {
 	}