From 48a6bd6ce7d1d078eea64da25cbe2ffee805fce8 Mon Sep 17 00:00:00 2001 From: Sam Brannen <104798+sbrannen@users.noreply.github.com> Date: Thu, 11 Jul 2024 12:33:48 +0200 Subject: [PATCH] Polishing --- .../spel/ast/FunctionReference.java | 3 +-- .../spel/support/ReflectionHelper.java | 23 +++++++++++-------- 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java index a798891f35d..8ffed18ca76 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/FunctionReference.java @@ -240,8 +240,7 @@ public class FunctionReference extends SpelNodeImpl { // to be packaged in an array, in contrast to how method invocation works with // reflection. int actualVarargsIndex = functionArgs.length - 1; - if (actualVarargsIndex >= 0 && functionArgs[actualVarargsIndex].getClass().isArray()) { - Object[] argsToUnpack = (Object[]) functionArgs[actualVarargsIndex]; + if (actualVarargsIndex >= 0 && functionArgs[actualVarargsIndex] instanceof Object[] argsToUnpack) { Object[] newArgs = new Object[actualVarargsIndex + argsToUnpack.length]; System.arraycopy(functionArgs, 0, newArgs, 0, actualVarargsIndex); System.arraycopy(argsToUnpack, 0, newArgs, actualVarargsIndex, argsToUnpack.length); diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java b/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java index b030b5c6c8a..0d918214524 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java @@ -279,7 +279,8 @@ public abstract class ReflectionHelper { for (int i = 0; i < arguments.length; i++) { TypeDescriptor targetType = new TypeDescriptor(MethodParameter.forExecutable(executable, i)); Object argument = arguments[i]; - arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType); + TypeDescriptor sourceType = TypeDescriptor.forObject(argument); + arguments[i] = converter.convertValue(argument, sourceType, targetType); conversionOccurred |= (argument != arguments[i]); } } @@ -288,7 +289,8 @@ public abstract class ReflectionHelper { for (int i = 0; i < varargsPosition; i++) { TypeDescriptor targetType = new TypeDescriptor(MethodParameter.forExecutable(executable, i)); Object argument = arguments[i]; - arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType); + TypeDescriptor sourceType = TypeDescriptor.forObject(argument); + arguments[i] = converter.convertValue(argument, sourceType, targetType); conversionOccurred |= (argument != arguments[i]); } @@ -318,7 +320,7 @@ public abstract class ReflectionHelper { // Possible outcomes of the above if-else block: // 1) the input argument was null, and nothing was done. // 2) the input argument was null; the varargs component type is Optional; and the argument was converted to Optional.empty(). - // 3) the input argument was correct type but not wrapped in an array, and nothing was done. + // 3) the input argument was the correct type but not wrapped in an array, and nothing was done. // 4) the input argument was already compatible (i.e., array of valid type), and nothing was done. // 5) the input argument was the wrong type and got converted and wrapped in an array. if (argument != arguments[varargsPosition] && @@ -364,7 +366,8 @@ public abstract class ReflectionHelper { TypeDescriptor targetType = new TypeDescriptor(resolvableType, argumentClass, null); Object argument = arguments[i]; - arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType); + TypeDescriptor sourceType = TypeDescriptor.forObject(argument); + arguments[i] = converter.convertValue(argument, sourceType, targetType); conversionOccurred |= (argument != arguments[i]); } } @@ -376,7 +379,8 @@ public abstract class ReflectionHelper { TypeDescriptor targetType = new TypeDescriptor(resolvableType, argumentClass, null); Object argument = arguments[i]; - arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), targetType); + TypeDescriptor sourceType = TypeDescriptor.forObject(argument); + arguments[i] = converter.convertValue(argument, sourceType, targetType); conversionOccurred |= (argument != arguments[i]); } @@ -407,9 +411,9 @@ public abstract class ReflectionHelper { // Possible outcomes of the above if-else block: // 1) the input argument was null, and nothing was done. // 2) the input argument was null; the varargs component type is Optional; and the argument was converted to Optional.empty(). - // 3) the input argument was correct type but not wrapped in an array, and nothing was done. - // 4) the input argument was already compatible (i.e., array of valid type), and nothing was done. - // 5) the input argument was the wrong type and got converted and wrapped in an array. + // 3) the input argument was the correct type but not wrapped in an array, and nothing was done. + // 4) the input argument was already compatible (i.e., an Object array of valid type), and nothing was done. + // 5) the input argument was the wrong type and got converted as explained in the comments above. if (argument != arguments[varargsPosition] && !isFirstEntryInArray(argument, arguments[varargsPosition])) { conversionOccurred = true; // case 5 @@ -419,7 +423,8 @@ public abstract class ReflectionHelper { else { for (int i = varargsPosition; i < arguments.length; i++) { Object argument = arguments[i]; - arguments[i] = converter.convertValue(argument, TypeDescriptor.forObject(argument), componentTypeDesc); + TypeDescriptor sourceType = TypeDescriptor.forObject(argument); + arguments[i] = converter.convertValue(argument, sourceType, componentTypeDesc); conversionOccurred |= (argument != arguments[i]); } }