pass full TypeDescriptor context through to ConversionService calls (SPR-7519)

Author: jhoeller

org.springframework.expression/src/main/java/org/springframework/expression/ConstructorResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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.
@@ -16,25 +16,29 @@
 
 package org.springframework.expression;
 
+import java.util.List;
+
+import org.springframework.core.convert.TypeDescriptor;
+
 /**
  * A constructor resolver attempts locate a constructor and returns a ConstructorExecutor that can be used to invoke
  * that constructor. The ConstructorExecutor will be cached but if it 'goes stale' the resolvers will be called again.
- * 
+ *
  * @author Andy Clement
  * @since 3.0
  */
 public interface ConstructorResolver {
 
 	/**
-	 * Within the supplied context determine a suitable constructor on the supplied type that can handle the specified
-	 * arguments. Return a ConstructorExecutor that can be used to invoke that constructor (or null if no constructor
-	 * could be found).
+	 * Within the supplied context determine a suitable constructor on the supplied type that can handle the
+	 * specified arguments. Return a ConstructorExecutor that can be used to invoke that constructor
+	 * (or <code>null</code> if no constructor could be found).
 	 * @param context the current evaluation context
 	 * @param typeName the type upon which to look for the constructor
 	 * @param argumentTypes the arguments that the constructor must be able to handle
 	 * @return a ConstructorExecutor that can invoke the constructor, or null if non found
 	 */
-	ConstructorExecutor resolve(EvaluationContext context, String typeName, Class<?>[] argumentTypes)
+	ConstructorExecutor resolve(EvaluationContext context, String typeName, List<TypeDescriptor> argumentTypes)
 			throws AccessException;
 
 }

org.springframework.expression/src/main/java/org/springframework/expression/MethodResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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.
@@ -16,24 +16,29 @@
 
 package org.springframework.expression;
 
+import java.util.List;
+
+import org.springframework.core.convert.TypeDescriptor;
+
 /**
- * A method resolver attempts locate a method and returns a command executor that can be used to invoke that method. The
- * command executor will be cached but if it 'goes stale' the resolvers will be called again.
- * 
+ * A method resolver attempts locate a method and returns a command executor that can be used to invoke that method.
+ * The command executor will be cached but if it 'goes stale' the resolvers will be called again.
+ *
  * @author Andy Clement
  * @since 3.0
  */
 public interface MethodResolver {
 
 	/**
-	 * Within the supplied context determine a suitable method on the supplied object that can handle the specified
-	 * arguments. Return a MethodExecutor that can be used to invoke that method (or null if no method
-	 * could be found).
+	 * Within the supplied context determine a suitable method on the supplied object that can handle the
+	 * specified arguments. Return a MethodExecutor that can be used to invoke that method
+	 * (or <code>null</code> if no method could be found).
 	 * @param context the current evaluation context
 	 * @param targetObject the object upon which the method is being called
 	 * @param argumentTypes the arguments that the constructor must be able to handle
 	 * @return a MethodExecutor that can invoke the method, or null if the method cannot be found
 	 */
-	MethodExecutor resolve(EvaluationContext context, Object targetObject, String name, Class<?>[] argumentTypes) throws AccessException;
+	MethodExecutor resolve(EvaluationContext context, Object targetObject, String name,
+			List<TypeDescriptor> argumentTypes) throws AccessException;
 
 }

org.springframework.expression/src/main/java/org/springframework/expression/TypeConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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,14 +30,6 @@
  */
 public interface TypeConverter {
 
-	/**
-	 * Return true if the type converter can convert the specified type to the desired target type.
-	 * @param sourceType the type to be converted from
-	 * @param targetType the type to be converted to
-	 * @return true if that conversion can be performed
-	 */
-	boolean canConvert(Class<?> sourceType, Class<?> targetType);
-
 	/**
 	 * Return true if the type converter can convert the specified type to the desired target type.
 	 * @param sourceType a type descriptor that describes the source type

org.springframework.expression/src/main/java/org/springframework/expression/spel/ast/ConstructorReference.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 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.
@@ -18,6 +18,7 @@
 
 import java.lang.reflect.Array;
 import java.util.List;
+import java.util.ArrayList;
 
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.expression.AccessException;
@@ -48,14 +49,16 @@
  */
 public class ConstructorReference extends SpelNodeImpl {
 
+	private boolean isArrayConstructor = false;
+
+	private SpelNodeImpl[] dimensions;
+
 	// TODO is this caching safe - passing the expression around will mean this executor is also being passed around
 	/**
 	 * The cached executor that may be reused on subsequent evaluations.
 	 */
 	private volatile ConstructorExecutor cachedExecutor;
 
-	private boolean isArrayConstructor = false;
-	private SpelNodeImpl[] dimensions;
 
 	/**
 	 * Create a constructor reference. The first argument is the type, the rest are the parameters to the constructor
@@ -76,40 +79,42 @@ public ConstructorReference(int pos, SpelNodeImpl[] dimensions, SpelNodeImpl...
 		this.dimensions = dimensions;
 	}
 
+
 	/**
 	 * Implements getValue() - delegating to the code for building an array or a simple type.
 	 */
 	@Override
 	public TypedValue getValueInternal(ExpressionState state) throws EvaluationException {
-		if (isArrayConstructor) {
+		if (this.isArrayConstructor) {
 			return createArray(state);
-		} else {
+		}
+		else {
 			return createNewInstance(state);
 		}
 	}
 
 	/**
 	 * Create a new ordinary object and return it.
-	 * 
 	 * @param state the expression state within which this expression is being evaluated
 	 * @return the new object
 	 * @throws EvaluationException if there is a problem creating the object
 	 */
 	private TypedValue createNewInstance(ExpressionState state) throws EvaluationException {
 		Object[] arguments = new Object[getChildCount() - 1];
-		Class<?>[] argumentTypes = new Class[getChildCount() - 1];
+		List<TypeDescriptor> argumentTypes = new ArrayList<TypeDescriptor>(getChildCount() - 1);
 		for (int i = 0; i < arguments.length; i++) {
-			TypedValue childValue = children[i + 1].getValueInternal(state);
+			TypedValue childValue = this.children[i + 1].getValueInternal(state);
 			Object value = childValue.getValue();
 			arguments[i] = value;
-			argumentTypes[i] = (value == null ? null : value.getClass());
+			argumentTypes.add(TypeDescriptor.forObject(value));
 		}
 
 		ConstructorExecutor executorToUse = this.cachedExecutor;
 		if (executorToUse != null) {
 			try {
 				return executorToUse.execute(state.getEvaluationContext(), arguments);
-			} catch (AccessException ae) {
+			}
+			catch (AccessException ae) {
 				// Two reasons this can occur:
 				// 1. the method invoked actually threw a real exception
 				// 2. the method invoked was not passed the arguments it expected and has become 'stale'
@@ -129,7 +134,7 @@ private TypedValue createNewInstance(ExpressionState state) throws EvaluationExc
 					if (rootCause instanceof RuntimeException) {
 						throw (RuntimeException) rootCause;
 					} else {
-						String typename = (String) children[0].getValueInternal(state).getValue();
+						String typename = (String) this.children[0].getValueInternal(state).getValue();
 						throw new SpelEvaluationException(getStartPosition(), rootCause,
 								SpelMessage.CONSTRUCTOR_INVOCATION_PROBLEM, typename, FormatHelper
 										.formatMethodForMessage("", argumentTypes));
@@ -142,13 +147,13 @@ private TypedValue createNewInstance(ExpressionState state) throws EvaluationExc
 		}
 
 		// either there was no accessor or it no longer exists
-		String typename = (String) children[0].getValueInternal(state).getValue();
+		String typename = (String) this.children[0].getValueInternal(state).getValue();
 		executorToUse = findExecutorForConstructor(typename, argumentTypes, state);
 		try {
 			this.cachedExecutor = executorToUse;
-			TypedValue result = executorToUse.execute(state.getEvaluationContext(), arguments);
-			return result;
-		} catch (AccessException ae) {
+			return executorToUse.execute(state.getEvaluationContext(), arguments);
+		}
+		catch (AccessException ae) {
 			throw new SpelEvaluationException(getStartPosition(), ae, SpelMessage.CONSTRUCTOR_INVOCATION_PROBLEM,
 					typename, FormatHelper.formatMethodForMessage("", argumentTypes));
 
@@ -158,14 +163,13 @@ private TypedValue createNewInstance(ExpressionState state) throws EvaluationExc
 	/**
 	 * Go through the list of registered constructor resolvers and see if any can find a constructor that takes the
 	 * specified set of arguments.
-	 * 
 	 * @param typename the type trying to be constructed
 	 * @param argumentTypes the types of the arguments supplied that the constructor must take
 	 * @param state the current state of the expression
 	 * @return a reusable ConstructorExecutor that can be invoked to run the constructor or null
 	 * @throws SpelEvaluationException if there is a problem locating the constructor
 	 */
-	private ConstructorExecutor findExecutorForConstructor(String typename, Class<?>[] argumentTypes,
+	private ConstructorExecutor findExecutorForConstructor(String typename, List<TypeDescriptor> argumentTypes,
 			ExpressionState state) throws SpelEvaluationException {
 
 		EvaluationContext eContext = state.getEvaluationContext();
@@ -178,10 +182,11 @@ private ConstructorExecutor findExecutorForConstructor(String typename, Class<?>
 					if (cEx != null) {
 						return cEx;
 					}
-				} catch (AccessException ex) {
+				}
+				catch (AccessException ex) {
 					throw new SpelEvaluationException(getStartPosition(), ex,
-							SpelMessage.CONSTRUCTOR_INVOCATION_PROBLEM, typename, FormatHelper.formatMethodForMessage(
-									"", argumentTypes));
+							SpelMessage.CONSTRUCTOR_INVOCATION_PROBLEM, typename,
+							FormatHelper.formatMethodForMessage("", argumentTypes));
 				}
 			}
 		}
@@ -208,13 +213,11 @@ public String toStringAST() {
 
 	/**
 	 * Create an array and return it.
-	 * 
 	 * @param state the expression state within which this expression is being evaluated
 	 * @return the new array
 	 * @throws EvaluationException if there is a problem creating the array
 	 */
 	private TypedValue createArray(ExpressionState state) throws EvaluationException {
-
 		// First child gives us the array type which will either be a primitive or reference type
 		Object intendedArrayType = getChild(0).getValue(state);
 		if (!(intendedArrayType instanceof String)) {
@@ -223,44 +226,44 @@ private TypedValue createArray(ExpressionState state) throws EvaluationException
 							.formatClassNameForMessage(intendedArrayType.getClass()));
 		}
 		String type = (String) intendedArrayType;
-		Class<?> componentType = null;
+		Class<?> componentType;
 		TypeCode arrayTypeCode = TypeCode.forName(type);
 		if (arrayTypeCode == TypeCode.OBJECT) {
 			componentType = state.findType(type);
-		} else {
+		}
+		else {
 			componentType = arrayTypeCode.getType();
 		}
-
 		TypeDescriptor td = TypeDescriptor.valueOf(componentType);
-
-		Object newArray = null;
-
+		Object newArray;
 		if (!hasInitializer()) {
 			// Confirm all dimensions were specified (for example [3][][5] is missing the 2nd dimension)
-			for (int i = 0; i < dimensions.length; i++) {
-				if (dimensions[i] == null) {
+			for (SpelNodeImpl dimension : this.dimensions) {
+				if (dimension == null) {
 					throw new SpelEvaluationException(getStartPosition(), SpelMessage.MISSING_ARRAY_DIMENSION);
 				}
 			}
 			TypeConverter typeConverter = state.getEvaluationContext().getTypeConverter();
 
 			// Shortcut for 1 dimensional
-			if (dimensions.length == 1) {
-				TypedValue o = dimensions[0].getTypedValue(state);
+			if (this.dimensions.length == 1) {
+				TypedValue o = this.dimensions[0].getTypedValue(state);
 				int arraySize = ExpressionUtils.toInt(typeConverter, o);
 				newArray = Array.newInstance(componentType, arraySize);
-			} else {
+			}
+			else {
 				// Multi-dimensional - hold onto your hat!
-				int[] dims = new int[dimensions.length];
-				for (int d = 0; d < dimensions.length; d++) {
-					TypedValue o = dimensions[d].getTypedValue(state);
+				int[] dims = new int[this.dimensions.length];
+				for (int d = 0; d < this.dimensions.length; d++) {
+					TypedValue o = this.dimensions[d].getTypedValue(state);
 					dims[d] = ExpressionUtils.toInt(typeConverter, o);
 				}
 				newArray = Array.newInstance(componentType, dims);
 			}
-		} else {
+		}
+		else {
 			// There is an initializer
-			if (dimensions.length > 1) {
+			if (this.dimensions.length > 1) {
 				// There is an initializer but this is a multi-dimensional array (e.g. new int[][]{{1,2},{3,4}}) - this
 				// is not currently supported
 				throw new SpelEvaluationException(getStartPosition(),
@@ -269,8 +272,8 @@ private TypedValue createArray(ExpressionState state) throws EvaluationException
 			TypeConverter typeConverter = state.getEvaluationContext().getTypeConverter();
 			InlineList initializer = (InlineList) getChild(1);
 			// If a dimension was specified, check it matches the initializer length
-			if (dimensions[0] != null) {
-				TypedValue dValue = dimensions[0].getTypedValue(state);
+			if (this.dimensions[0] != null) {
+				TypedValue dValue = this.dimensions[0].getTypedValue(state);
 				int i = ExpressionUtils.toInt(typeConverter, dValue);
 				if (i != initializer.getChildCount()) {
 					throw new SpelEvaluationException(getStartPosition(), SpelMessage.INITIALIZER_LENGTH_INCORRECT);
@@ -281,27 +284,35 @@ private TypedValue createArray(ExpressionState state) throws EvaluationException
 			newArray = Array.newInstance(componentType, arraySize);
 			if (arrayTypeCode == TypeCode.OBJECT) {
 				populateReferenceTypeArray(state, newArray, typeConverter, initializer, componentType);
-			} else if (arrayTypeCode == TypeCode.INT) {
+			}
+			else if (arrayTypeCode == TypeCode.INT) {
 				populateIntArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.BOOLEAN) {
+			}
+			else if (arrayTypeCode == TypeCode.BOOLEAN) {
 				populateBooleanArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.CHAR) {
+			}
+			else if (arrayTypeCode == TypeCode.CHAR) {
 				populateCharArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.LONG) {
+			}
+			else if (arrayTypeCode == TypeCode.LONG) {
 				populateLongArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.SHORT) {
+			}
+			else if (arrayTypeCode == TypeCode.SHORT) {
 				populateShortArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.DOUBLE) {
+			}
+			else if (arrayTypeCode == TypeCode.DOUBLE) {
 				populateDoubleArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.FLOAT) {
+			}
+			else if (arrayTypeCode == TypeCode.FLOAT) {
 				populateFloatArray(state, newArray, typeConverter, initializer);
-			} else if (arrayTypeCode == TypeCode.BYTE) {
+			}
+			else if (arrayTypeCode == TypeCode.BYTE) {
 				populateByteArray(state, newArray, typeConverter, initializer);
-			} else {
+			}
+			else {
 				throw new IllegalStateException(arrayTypeCode.name());
 			}
 		}
-
 		return new TypedValue(newArray, td);
 	}