Merge pull request #97 from sbrannen/SPR-9493

* SPR-9493:
  Infer return type of parametrized factory methods

Author: sbrannen

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -63,6 +63,7 @@
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.beans.factory.config.ConstructorArgumentValues.ValueHolder;
 import org.springframework.beans.factory.config.DependencyDescriptor;
 import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
 import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
@@ -106,6 +107,7 @@
  * @author Mark Fisher
  * @author Costin Leau
  * @author Chris Beams
+ * @author Sam Brannen
  * @since 13.02.2004
  * @see RootBeanDefinition
  * @see DefaultListableBeanFactory
@@ -628,16 +630,26 @@ protected Class getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd,
 			return null;
 		}
 
+		List<ValueHolder> argumentValues = mbd.getConstructorArgumentValues().getGenericArgumentValues();
+		Object[] args = new Object[argumentValues.size()];
+		for (int i = 0; i < args.length; i++) {
+			args[i] = argumentValues.get(i).getValue();
+		}
+
 		// If all factory methods have the same return type, return that type.
 		// Can't clearly figure out exact method due to type converting / autowiring!
 		int minNrOfArgs = mbd.getConstructorArgumentValues().getArgumentCount();
 		Method[] candidates = ReflectionUtils.getUniqueDeclaredMethods(factoryClass);
-		Set<Class> returnTypes = new HashSet<Class>(1);
+		Set<Class<?>> returnTypes = new HashSet<Class<?>>(1);
 		for (Method factoryMethod : candidates) {
-			if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic &&
-					factoryMethod.getName().equals(mbd.getFactoryMethodName()) &&
-					factoryMethod.getParameterTypes().length >= minNrOfArgs) {
-				returnTypes.add(factoryMethod.getReturnType());
+			if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic
+					&& factoryMethod.getName().equals(mbd.getFactoryMethodName())
+					&& factoryMethod.getParameterTypes().length >= minNrOfArgs) {
+
+				Class<?> returnType = GenericTypeResolver.resolveParameterizedReturnType(factoryMethod, args);
+				if (returnType != null) {
+					returnTypes.add(returnType);
+				}
 			}
 		}
 

spring-beans/src/test/java/org/springframework/beans/factory/support/BeanFactoryGenericsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2012 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,8 @@
 import java.util.Set;
 
 import static org.junit.Assert.*;
+
+import org.easymock.EasyMock;
 import org.junit.Test;
 import test.beans.GenericBean;
 import test.beans.GenericIntegerBean;
@@ -46,6 +48,7 @@
 /**
  * @author Juergen Hoeller
  * @author Chris Beams
+ * @author Sam Brannen
  * @since 20.01.2006
  */
 public class BeanFactoryGenericsTests {
@@ -619,6 +622,30 @@ public void testSetBean() throws Exception {
 		assertEquals(new URL("http://www.springframework.org"), us.iterator().next());
 	}
 
+	/**
+	 * Tests support for parameterized {@code factory-method} declarations such
+	 * as EasyMock's {@code createMock()} method which has the following signature.
+	 *
+	 * <pre>{@code
+	 * public static <T> T createMock(Class<T> toMock)
+	 * }</pre>
+	 *
+	 * @since 3.2
+	 * @see SPR-9493
+	 */
+	@Test
+	public void parameterizedFactoryMethod() {
+		RootBeanDefinition rbd = new RootBeanDefinition(EasyMock.class);
+		rbd.setFactoryMethodName("createMock");
+		rbd.getConstructorArgumentValues().addGenericArgumentValue(Runnable.class);
+
+		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
+		bf.registerBeanDefinition("easyMock", rbd);
+
+		Map<String, Runnable> beans = bf.getBeansOfType(Runnable.class);
+		assertEquals(1, beans.size());
+	}
+
 
 	@SuppressWarnings("serial")
 	public static class NamedUrlList extends LinkedList<URL> {

spring-beans/src/test/java/org/springframework/beans/factory/xml/FactoryMethodTests.java

@@ -28,7 +28,6 @@
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.BeanDefinitionStoreException;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
-import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
 import org.springframework.core.io.ClassPathResource;
 
 /**

spring-beans/src/test/resources/log4j.xml

@@ -19,6 +19,10 @@
 		<level value="debug" />
 	</logger>
 
+	<logger name="org.springframework.core.GenericTypeResolver">
+		<level value="warn" />
+	</logger>
+
 	<!-- Root Logger -->
 	<root>
 		<priority value="warn" />

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -30,7 +30,11 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 
 /**
  * Helper class for resolving generic types against type variables.
@@ -40,11 +44,14 @@
  *
  * @author Juergen Hoeller
  * @author Rob Harrop
+ * @author Sam Brannen
  * @since 2.5.2
  * @see GenericCollectionTypeResolver
  */
 public abstract class GenericTypeResolver {
 
+	private static final Log logger = LogFactory.getLog(GenericTypeResolver.class);
+
 	/** Cache from Class to TypeVariable Map */
 	private static final Map<Class, Reference<Map<TypeVariable, Type>>> typeVariableCache =
 			Collections.synchronizedMap(new WeakHashMap<Class, Reference<Map<TypeVariable, Type>>>());
@@ -88,18 +95,144 @@ public static Class<?> resolveParameterType(MethodParameter methodParam, Class c
 	}
 
 	/**
-	 * Determine the target type for the generic return type of the given method.
+	 * Determine the target type for the generic return type of the given method,
+	 * where the type variable is declared on the given class.
+	 *
 	 * @param method the method to introspect
 	 * @param clazz the class to resolve type variables against
 	 * @return the corresponding generic parameter or return type
+	 * @see #resolveParameterizedReturnType
 	 */
-	public static Class<?> resolveReturnType(Method method, Class clazz) {
+	public static Class<?> resolveReturnType(Method method, Class<?> clazz) {
 		Assert.notNull(method, "Method must not be null");
 		Type genericType = method.getGenericReturnType();
 		Assert.notNull(clazz, "Class must not be null");
 		Map<TypeVariable, Type> typeVariableMap = getTypeVariableMap(clazz);
 		Type rawType = getRawType(genericType, typeVariableMap);
-		return (rawType instanceof Class ? (Class) rawType : method.getReturnType());
+		return (rawType instanceof Class ? (Class<?>) rawType : method.getReturnType());
+	}
+
+	/**
+	 * Determine the target type for the generic return type of the given
+	 * <em>parameterized</em> method, where the type variable is declared
+	 * on the given method.
+	 *
+	 * <p>For example, given a factory method with the following signature,
+	 * if {@code resolveParameterizedReturnType()} is invoked with the reflected
+	 * method for {@code creatProxy()} and an {@code Object[]} array containing
+	 * {@code MyService.class}, {@code resolveParameterizedReturnType()} will
+	 * infer that the target return type is {@code MyService}.
+	 *
+	 * <pre>{@code public static <T> T createProxy(Class<T> clazz)}</pre>
+	 *
+	 * <h4>Possible Return Values</h4>
+	 * <ul>
+	 * <li>the target return type if it can be inferred</li>
+	 * <li>the {@link Method#getReturnType() standard return type}, if
+	 * the given {@code method} does not declare any {@link
+	 * Method#getTypeParameters() generic types}</li>
+	 * <li>the {@link Method#getReturnType() standard return type}, if the
+	 * target return type cannot be inferred (e.g., due to type erasure)</li>
+	 * <li>{@code null}, if the length of the given arguments array is shorter
+	 * than the length of the {@link
+	 * Method#getGenericParameterTypes() formal argument list} for the given
+	 * method</li>
+	 * </ul>
+	 *
+	 * @param method the method to introspect, never {@code null}
+	 * @param args the arguments that will be supplied to the method when it is
+	 * invoked, never {@code null}
+	 * @return the resolved target return type, the standard return type, or
+	 * {@code null}
+	 * @since 3.2
+	 * @see #resolveReturnType
+	 */
+	public static Class<?> resolveParameterizedReturnType(Method method, Object[] args) {
+		Assert.notNull(method, "method must not be null");
+		Assert.notNull(args, "args must not be null");
+
+		final TypeVariable<Method>[] declaredGenericTypes = method.getTypeParameters();
+		final Type genericReturnType = method.getGenericReturnType();
+		final Type[] genericArgumentTypes = method.getGenericParameterTypes();
+
+		if (logger.isDebugEnabled()) {
+			logger.debug(String.format(
+				"Resolving parameterized return type for [%s] with concrete method arguments [%s].",
+				method.toGenericString(), ObjectUtils.nullSafeToString(args)));
+		}
+
+		// No declared generic types to inspect, so just return the standard return type.
+		if (declaredGenericTypes.length == 0) {
+			return method.getReturnType();
+		}
+
+		// The supplied argument list is too short for the method's signature, so
+		// return null, since such a method invocation would fail.
+		if (args.length < genericArgumentTypes.length) {
+			return null;
+		}
+
+		// Ensure that the generic type is declared directly on the method
+		// itself, not on the enclosing class or interface.
+		boolean locallyDeclaredGenericTypeMatchesReturnType = false;
+		for (TypeVariable<Method> currentType : declaredGenericTypes) {
+			if (currentType.equals(genericReturnType)) {
+				if (logger.isDebugEnabled()) {
+					logger.debug(String.format(
+						"Found declared generic type [%s] that matches the target return type [%s].",
+						currentType, genericReturnType));
+				}
+				locallyDeclaredGenericTypeMatchesReturnType = true;
+				break;
+			}
+		}
+
+		if (locallyDeclaredGenericTypeMatchesReturnType) {
+			for (int i = 0; i < genericArgumentTypes.length; i++) {
+				final Type currentArgumentType = genericArgumentTypes[i];
+
+				if (currentArgumentType.equals(genericReturnType)) {
+					if (logger.isDebugEnabled()) {
+						logger.debug(String.format(
+							"Found generic method argument at index [%s] that matches the target return type.", i));
+					}
+					return args[i].getClass();
+				}
+
+				if (currentArgumentType instanceof ParameterizedType) {
+					ParameterizedType parameterizedType = (ParameterizedType) currentArgumentType;
+					Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+
+					for (int j = 0; j < actualTypeArguments.length; j++) {
+						final Type typeArg = actualTypeArguments[j];
+
+						if (typeArg.equals(genericReturnType)) {
+							if (logger.isDebugEnabled()) {
+								logger.debug(String.format(
+									"Found method argument at index [%s] that is parameterized with a type that matches the target return type.",
+									i));
+							}
+
+							if (args[i] instanceof Class) {
+								return (Class<?>) args[i];
+							} else {
+								// Consider adding logic to determine the class of the
+								// J'th typeArg, if possible.
+								logger.info(String.format(
+									"Could not determine the target type for parameterized type [%s] for method [%s].",
+									typeArg, method.toGenericString()));
+
+								// For now, just fall back...
+								return method.getReturnType();
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Fall back...
+		return method.getReturnType();
 	}
 
 	/**
@@ -128,7 +261,7 @@ public static Class<?> resolveReturnTypeArgument(Method method, Class<?> generic
 				return null;
 			}
 		}
-		return GenericTypeResolver.resolveTypeArgument((Class<?>) returnType, genericIfc);
+		return resolveTypeArgument((Class<?>) returnType, genericIfc);
 	}
 
 	/**
@@ -186,7 +319,7 @@ private static Class[] doResolveTypeArguments(Class ownerClass, Class classToInt
 		}
 		return null;
 	}
-	
+
 	private static Class[] doResolveTypeArguments(Class ownerClass, Type ifc, Class genericIfc) {
 		if (ifc instanceof ParameterizedType) {
 			ParameterizedType paramIfc = (ParameterizedType) ifc;
@@ -236,7 +369,6 @@ else if (arg instanceof TypeVariable) {
 		return (arg instanceof Class ? (Class) arg : Object.class);
 	}
 
-
 	/**
 	 * Resolve the specified generic type against the given TypeVariable map.
 	 * @param genericType the generic type to resolve
@@ -272,9 +404,9 @@ static Type getRawType(Type genericType, Map<TypeVariable, Type> typeVariableMap
 	}
 
 	/**
-	 * Build a mapping of {@link TypeVariable#getName TypeVariable names} to concrete
-	 * {@link Class} for the specified {@link Class}. Searches all super types,
-	 * enclosing types and interfaces.
+	 * Build a mapping of {@link TypeVariable#getName TypeVariable names} to
+	 * {@link Class concrete classes} for the specified {@link Class}. Searches
+	 * all super types, enclosing types and interfaces.
 	 */
 	public static Map<TypeVariable, Type> getTypeVariableMap(Class clazz) {
 		Reference<Map<TypeVariable, Type>> ref = typeVariableCache.get(clazz);