root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Merge ArgumentsMatchInfo into ArgumentsMatchKind in SpEL 

The internal ArgumentsMatchInfo type seems to have once had additional
methods beyond the functionality provided by the ArgumentsMatchKind
enum; however, that is no longer the case. Consequently, there is no
need to maintain both types.

This commit therefore merges the convenience methods from
ArgumentsMatchInfo into the ArgumentsMatchKind enum and removes the
unnecessary ArgumentsMatchInfo type.
This commit is contained in:
Sam Brannen 2024-07-13 14:34:24 +02:00
parent 007a347ade
commit 6ca8fbc2da
4 changed files with 50 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java
View File

@ -58,7 +58,7 @@ public abstract class ReflectionHelper {
* or {@code null} if it was not a match
*/
@Nullable
static ArgumentsMatchInfo compareArguments(
static ArgumentsMatchKind compareArguments(
List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) {
Assert.isTrue(expectedArgTypes.size() == suppliedArgTypes.size(),
@ -88,7 +88,7 @@ public abstract class ReflectionHelper {
}
}
}
return (match != null ? new ArgumentsMatchInfo(match) : null);
return match;
}
/**
@ -143,11 +143,11 @@ public abstract class ReflectionHelper {
* @param expectedArgTypes the types the method/constructor is expecting
* @param suppliedArgTypes the types that are being supplied at the point of invocation
* @param typeConverter a registered type converter
* @return an {@code ArgumentsMatchInfo} object indicating what kind of match it was,
* @return an {@code ArgumentsMatchKind} object indicating what kind of match it was,
* or {@code null} if it was not a match
*/
@Nullable
static ArgumentsMatchInfo compareArgumentsVarargs(
static ArgumentsMatchKind compareArgumentsVarargs(
List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) {
Assert.isTrue(!CollectionUtils.isEmpty(expectedArgTypes),
@ -231,7 +231,7 @@ public abstract class ReflectionHelper {
}
}
return (match != null ? new ArgumentsMatchInfo(match) : null);
return match;
}
/**
@ -507,45 +507,37 @@ public abstract class ReflectionHelper {
/**
* Arguments match kinds.
* {@code ArgumentsMatchKind} describes what kind of match was achieved between two sets
* of arguments: the set that a method/constructor is expecting and the set that is being
* supplied at the point of invocation.
*/
enum ArgumentsMatchKind {
/** An exact match is where the parameter types exactly match what the method/constructor is expecting. */
/**
* An exact match is where the parameter types exactly match what the method/constructor is expecting.
*/
EXACT,
/** A close match is where the parameter types either exactly match or are assignment-compatible. */
/**
* A close match is where the parameter types either exactly match or are assignment-compatible.
*/
CLOSE,
/** A conversion match is where the type converter must be used to transform some of the parameter types. */
REQUIRES_CONVERSION
}
/**
* An instance of {@code ArgumentsMatchInfo} describes what kind of match was achieved
* between two sets of arguments - the set that a method/constructor is expecting
* and the set that is being supplied at the point of invocation.
*
* @param kind the kind of match that was achieved
*/
record ArgumentsMatchInfo(ArgumentsMatchKind kind) {
/**
* A conversion match is where the type converter must be used to transform some of the parameter types.
*/
REQUIRES_CONVERSION;
public boolean isExactMatch() {
return (this.kind == ArgumentsMatchKind.EXACT);
return (this == EXACT);
}
public boolean isCloseMatch() {
return (this.kind == ArgumentsMatchKind.CLOSE);
return (this == CLOSE);
}
public boolean isMatchRequiringConversion() {
return (this.kind == ArgumentsMatchKind.REQUIRES_CONVERSION);
}
@Override
public String toString() {
return "ArgumentsMatchInfo: " + this.kind;
return (this == REQUIRES_CONVERSION);
}
}

15
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorResolver.java
View File

@ -30,6 +30,7 @@ import org.springframework.expression.ConstructorResolver;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.EvaluationException;
import org.springframework.expression.TypeConverter;
import org.springframework.expression.spel.support.ReflectionHelper.ArgumentsMatchKind;
import org.springframework.lang.Nullable;
/**
@ -75,7 +76,7 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
for (int i = 0; i < paramCount; i++) {
paramDescriptors.add(new TypeDescriptor(new MethodParameter(ctor, i)));
}
ReflectionHelper.ArgumentsMatchInfo matchInfo = null;
ArgumentsMatchKind matchKind = null;
if (ctor.isVarArgs() && argumentTypes.size() >= paramCount - 1) {
// *sigh* complicated
// Basically.. we have to have all parameters match up until the varargs one, then the rest of what is
@ -83,20 +84,20 @@ public class ReflectiveConstructorResolver implements ConstructorResolver {
// the same type whilst the final argument to the method must be an array of that (oh, how easy...not) -
// or the final parameter
// we are supplied does match exactly (it is an array already).
matchInfo = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
matchKind = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
}
else if (paramCount == argumentTypes.size()) {
// worth a closer look
matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
matchKind = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
}
if (matchInfo != null) {
if (matchInfo.isExactMatch()) {
if (matchKind != null) {
if (matchKind.isExactMatch()) {
return new ReflectiveConstructorExecutor(ctor);
}
else if (matchInfo.isCloseMatch()) {
else if (matchKind.isCloseMatch()) {
closeMatch = ctor;
}
else if (matchInfo.isMatchRequiringConversion()) {
else if (matchKind.isMatchRequiringConversion()) {
matchRequiringConversion = ctor;
}
}

15
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodResolver.java
View File

@ -39,6 +39,7 @@ import org.springframework.expression.MethodResolver;
import org.springframework.expression.TypeConverter;
import org.springframework.expression.spel.SpelEvaluationException;
import org.springframework.expression.spel.SpelMessage;
import org.springframework.expression.spel.support.ReflectionHelper.ArgumentsMatchKind;
import org.springframework.lang.Nullable;
/**
@ -169,20 +170,20 @@ public class ReflectiveMethodResolver implements MethodResolver {
for (int i = 0; i < paramCount; i++) {
paramDescriptors.add(new TypeDescriptor(new MethodParameter(method, i)));
}
ReflectionHelper.ArgumentsMatchInfo matchInfo = null;
ArgumentsMatchKind matchKind = null;
if (method.isVarArgs() && argumentTypes.size() >= (paramCount - 1)) {
// *sigh* complicated
matchInfo = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
matchKind = ReflectionHelper.compareArgumentsVarargs(paramDescriptors, argumentTypes, typeConverter);
}
else if (paramCount == argumentTypes.size()) {
// Name and parameter number match, check the arguments
matchInfo = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
matchKind = ReflectionHelper.compareArguments(paramDescriptors, argumentTypes, typeConverter);
}
if (matchInfo != null) {
if (matchInfo.isExactMatch()) {
if (matchKind != null) {
if (matchKind.isExactMatch()) {
return new ReflectiveMethodExecutor(method, type);
}
else if (matchInfo.isCloseMatch()) {
else if (matchKind.isCloseMatch()) {
if (this.useDistance) {
int matchDistance = ReflectionHelper.getTypeDifferenceWeight(paramDescriptors, argumentTypes);
if (closeMatch == null || matchDistance < closeMatchDistance) {
@ -198,7 +199,7 @@ public class ReflectiveMethodResolver implements MethodResolver {
}
}
}
else if (matchInfo.isMatchRequiringConversion()) {
else if (matchKind.isMatchRequiringConversion()) {
if (matchRequiringConversion != null) {
multipleOptions = true;
}

26
spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java
View File

@ -450,22 +450,22 @@ class ReflectionHelperTests extends AbstractExpressionTests {
* Used to validate the match returned from a compareArguments call.
*/
private void checkMatch(Class<?>[] inputTypes, Class<?>[] expectedTypes, StandardTypeConverter typeConverter, ArgumentsMatchKind expectedMatchKind) {
ReflectionHelper.ArgumentsMatchInfo matchInfo = ReflectionHelper.compareArguments(typeDescriptors(expectedTypes), typeDescriptors(inputTypes), typeConverter);
ArgumentsMatchKind matchKind = ReflectionHelper.compareArguments(typeDescriptors(expectedTypes), typeDescriptors(inputTypes), typeConverter);
if (expectedMatchKind == null) {
assertThat(matchInfo).as("Did not expect them to match in any way").isNull();
assertThat(matchKind).as("Did not expect them to match in any way").isNull();
}
else {
assertThat(matchInfo).as("Should not be a null match").isNotNull();
assertThat(matchKind).as("Should not be a null match").isNotNull();
}
if (expectedMatchKind == EXACT) {
assertThat(matchInfo.isExactMatch()).isTrue();
assertThat(matchKind.isExactMatch()).isTrue();
}
else if (expectedMatchKind == CLOSE) {
assertThat(matchInfo.isCloseMatch()).isTrue();
assertThat(matchKind.isCloseMatch()).isTrue();
}
else if (expectedMatchKind == REQUIRES_CONVERSION) {
assertThat(matchInfo.isMatchRequiringConversion()).as("expected to be a match requiring conversion, but was " + matchInfo).isTrue();
assertThat(matchKind.isMatchRequiringConversion()).as("expected to be a match requiring conversion, but was " + matchKind).isTrue();
}
}
@ -475,18 +475,18 @@ class ReflectionHelperTests extends AbstractExpressionTests {
private static void checkMatchVarargs(Class<?>[] inputTypes, Class<?>[] expectedTypes,
StandardTypeConverter typeConverter, ArgumentsMatchKind expectedMatchKind) {
ReflectionHelper.ArgumentsMatchInfo matchInfo =
ArgumentsMatchKind matchKind =
ReflectionHelper.compareArgumentsVarargs(typeDescriptors(expectedTypes), typeDescriptors(inputTypes), typeConverter);
if (expectedMatchKind == null) {
assertThat(matchInfo).as("Did not expect them to match in any way: " + matchInfo).isNull();
assertThat(matchKind).as("Did not expect them to match in any way: " + matchKind).isNull();
}
else {
assertThat(matchInfo).as("Should not be a null match").isNotNull();
assertThat(matchKind).as("Should not be a null match").isNotNull();
switch (expectedMatchKind) {
case EXACT -> assertThat(matchInfo.isExactMatch()).isTrue();
case CLOSE -> assertThat(matchInfo.isCloseMatch()).isTrue();
case REQUIRES_CONVERSION -> assertThat(matchInfo.isMatchRequiringConversion())
.as("expected to be a match requiring conversion, but was " + matchInfo).isTrue();
case EXACT -> assertThat(matchKind.isExactMatch()).isTrue();
case CLOSE -> assertThat(matchKind.isCloseMatch()).isTrue();
case REQUIRES_CONVERSION -> assertThat(matchKind.isMatchRequiringConversion())
.as("expected to be a match requiring conversion, but was " + matchKind).isTrue();
}
}
}