GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

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.
pull/33213/head
Sam Brannen 1 year ago
parent
007a347ade
commit
6ca8fbc2da
4 changed files with 50 additions and 56 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 50
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java
  2. 15
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveConstructorResolver.java
  3. 15
      spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectiveMethodResolver.java
  4. 26
      spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java

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

@ -58,7 +58,7 @@ public abstract class ReflectionHelper {
* or {@code null} if it was not a match * or {@code null} if it was not a match
*/ */
@Nullable @Nullable
static ArgumentsMatchInfo compareArguments( static ArgumentsMatchKind compareArguments(
List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) { List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) {
Assert.isTrue(expectedArgTypes.size() == suppliedArgTypes.size(), 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 expectedArgTypes the types the method/constructor is expecting
* @param suppliedArgTypes the types that are being supplied at the point of invocation * @param suppliedArgTypes the types that are being supplied at the point of invocation
* @param typeConverter a registered type converter * @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 * or {@code null} if it was not a match
*/ */
@Nullable @Nullable
static ArgumentsMatchInfo compareArgumentsVarargs( static ArgumentsMatchKind compareArgumentsVarargs(
List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) { List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter) {
Assert.isTrue(!CollectionUtils.isEmpty(expectedArgTypes), 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 { 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, 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, CLOSE,
/** A conversion match is where the type converter must be used to transform some of the parameter types. */ /**
REQUIRES_CONVERSION * 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) {
public boolean isExactMatch() { public boolean isExactMatch() {
return (this.kind == ArgumentsMatchKind.EXACT); return (this == EXACT);
} }
public boolean isCloseMatch() { public boolean isCloseMatch() {
return (this.kind == ArgumentsMatchKind.CLOSE); return (this == CLOSE);
} }
public boolean isMatchRequiringConversion() { public boolean isMatchRequiringConversion() {
return (this.kind == ArgumentsMatchKind.REQUIRES_CONVERSION); return (this == REQUIRES_CONVERSION);
}
@Override
public String toString() {
return "ArgumentsMatchInfo: " + this.kind;
} }
} }

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

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

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

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

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

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

Write Preview
Loading…
Cancel
Save