Polishing

Author: sbrannen

spring-core/src/main/java/org/springframework/aot/hint/JdkProxyHint.java

@@ -158,7 +158,7 @@ private static List<TypeReference> toTypeReferences(Class<?>... proxiedInterface
 			if (!invalidTypes.isEmpty()) {
 				throw new IllegalArgumentException("The following must be non-sealed interfaces: " + invalidTypes);
 			}
-			return Arrays.stream(proxiedInterfaces).map(TypeReference::of).toList();
+			return TypeReference.listOf(proxiedInterfaces);
 		}
 
 	}

spring-core/src/main/java/org/springframework/aot/hint/ReflectionHints.java

@@ -20,12 +20,10 @@
 import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.springframework.aot.hint.TypeHint.Builder;
@@ -255,7 +253,7 @@ public ReflectionHints registerMethod(Method method, Consumer<ExecutableHint.Bui
 	}
 
 	private List<TypeReference> mapParameters(Executable executable) {
-		return Arrays.stream(executable.getParameterTypes()).map(TypeReference::of).collect(Collectors.toList());
+		return TypeReference.listOf(executable.getParameterTypes());
 	}
 
 }

spring-core/src/main/java/org/springframework/aot/hint/TypeHint.java

@@ -312,8 +312,7 @@ private static final class ExecutableKey {
 
 		private ExecutableKey(String name, List<TypeReference> parameterTypes) {
 			this.name = name;
-			this.parameterTypes = parameterTypes.stream().map(TypeReference::getCanonicalName)
-					.collect(Collectors.toList());
+			this.parameterTypes = parameterTypes.stream().map(TypeReference::getCanonicalName).toList();
 		}
 
 		@Override

spring-core/src/main/java/org/springframework/aot/hint/predicate/ProxyHintsPredicates.java

@@ -17,6 +17,7 @@
 package org.springframework.aot.hint.predicate;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.function.Predicate;
 
 import org.springframework.aot.hint.ProxyHints;
@@ -59,7 +60,9 @@ public Predicate<RuntimeHints> forInterfaces(Class<?>... interfaces) {
 	 */
 	public Predicate<RuntimeHints> forInterfaces(TypeReference... interfaces) {
 		Assert.notEmpty(interfaces, "'interfaces' should not be empty");
+		List<TypeReference> interfaceList = Arrays.asList(interfaces);
 		return hints -> hints.proxies().jdkProxies().anyMatch(proxyHint ->
-				proxyHint.getProxiedInterfaces().equals(Arrays.asList(interfaces)));
+				proxyHint.getProxiedInterfaces().equals(interfaceList));
 	}
+
 }

spring-core/src/main/java/org/springframework/aot/hint/predicate/ReflectionHintsPredicates.java

@@ -49,7 +49,6 @@
 public class ReflectionHintsPredicates {
 
 	ReflectionHintsPredicates() {
-
 	}
 
 	/**
@@ -138,10 +137,10 @@ private Method getMethod(Class<?> type, String methodName) {
 			return methods.iterator().next();
 		}
 		else if (methods.size() > 1) {
-			throw new IllegalArgumentException(String.format("Found multiple methods named '%s' on class %s", methodName, type.getName()));
+			throw new IllegalArgumentException("Found multiple methods named '%s' on class %s".formatted(methodName, type.getName()));
 		}
 		else {
-			throw new IllegalArgumentException("No method named '" + methodName + "' on class " + type.getName());
+			throw new IllegalArgumentException("No method named '%s' on class %s".formatted(methodName, type.getName()));
 		}
 	}
 
@@ -160,7 +159,7 @@ public FieldHintPredicate onField(Class<?> type, String fieldName) {
 		Assert.hasText(fieldName, "'fieldName' should not be empty");
 		Field field = ReflectionUtils.findField(type, fieldName);
 		if (field == null) {
-			throw new IllegalArgumentException("No field named '" + fieldName + "' on class " + type.getName());
+			throw new IllegalArgumentException("No field named '%s' on class %s".formatted(fieldName, type.getName()));
 		}
 		return new FieldHintPredicate(field);
 	}
@@ -315,15 +314,13 @@ public boolean test(RuntimeHints runtimeHints) {
 		/**
 		 * Indicate whether the specified {@code ExecutableHint} covers the
 		 * reflection needs of the specified executable definition.
-		 * @return {@code true} if the member matches (same type, name and parameters),
-		 * and the configured {@code ExecutableMode} is compatibe
+		 * @return {@code true} if the member matches (same type, name, and parameters),
+		 * and the configured {@code ExecutableMode} is compatible
 		 */
 		static boolean includes(ExecutableHint hint, String name,
 				List<TypeReference> parameterTypes, ExecutableMode executableModes) {
-			return hint.getName().equals(name)
-					&& hint.getParameterTypes().equals(parameterTypes)
-					&& (hint.getMode().equals(ExecutableMode.INVOKE)
-					|| !executableModes.equals(ExecutableMode.INVOKE));
+			return hint.getName().equals(name) && hint.getParameterTypes().equals(parameterTypes) &&
+					(hint.getMode().equals(ExecutableMode.INVOKE) || !executableModes.equals(ExecutableMode.INVOKE));
 		}
 	}
 
@@ -355,18 +352,15 @@ MemberCategory[] getDeclaredMemberCategories() {
 		Predicate<RuntimeHints> exactMatch() {
 			return hints -> (hints.reflection().getTypeHint(this.executable.getDeclaringClass()) != null) &&
 					hints.reflection().getTypeHint(this.executable.getDeclaringClass()).constructors().anyMatch(executableHint -> {
-						List<TypeReference> parameters = Arrays.stream(this.executable.getParameterTypes())
-								.map(TypeReference::of).toList();
-						return includes(executableHint, "<init>",
-								parameters, this.executableMode);
+						List<TypeReference> parameters = TypeReference.listOf(this.executable.getParameterTypes());
+						return includes(executableHint, "<init>", parameters, this.executableMode);
 					});
 		}
 
 	}
 
 	public static class MethodHintPredicate extends ExecutableHintPredicate<Method> {
 
-
 		MethodHintPredicate(Method method) {
 			super(method);
 		}
@@ -394,10 +388,8 @@ MemberCategory[] getDeclaredMemberCategories() {
 		Predicate<RuntimeHints> exactMatch() {
 			return hints -> (hints.reflection().getTypeHint(this.executable.getDeclaringClass()) != null) &&
 					hints.reflection().getTypeHint(this.executable.getDeclaringClass()).methods().anyMatch(executableHint -> {
-						List<TypeReference> parameters = Arrays.stream(this.executable.getParameterTypes())
-								.map(TypeReference::of).toList();
-						return includes(executableHint, this.executable.getName(),
-								parameters, this.executableMode);
+						List<TypeReference> parameters = TypeReference.listOf(this.executable.getParameterTypes());
+						return includes(executableHint, this.executable.getName(), parameters, this.executableMode);
 					});
 		}
 
@@ -422,8 +414,8 @@ public boolean test(RuntimeHints runtimeHints) {
 
 		private boolean memberCategoryMatch(TypeHint typeHint) {
 			if (Modifier.isPublic(this.field.getModifiers())) {
-				return typeHint.getMemberCategories().contains(MemberCategory.PUBLIC_FIELDS)
-						|| typeHint.getMemberCategories().contains(MemberCategory.DECLARED_FIELDS);
+				return typeHint.getMemberCategories().contains(MemberCategory.PUBLIC_FIELDS) ||
+						typeHint.getMemberCategories().contains(MemberCategory.DECLARED_FIELDS);
 			}
 			else {
 				return typeHint.getMemberCategories().contains(MemberCategory.DECLARED_FIELDS);
@@ -434,6 +426,7 @@ private boolean exactMatch(TypeHint typeHint) {
 			return typeHint.fields().anyMatch(fieldHint ->
 					this.field.getName().equals(fieldHint.getName()));
 		}
+
 	}
 
 }

spring-core/src/test/java/org/springframework/aot/hint/ProxyHintsTests.java

@@ -96,17 +96,13 @@ private static Consumer<JdkProxyHint> proxiedInterfaces(String... proxiedInterfa
 
 	private static Consumer<JdkProxyHint> proxiedInterfaces(Class<?>... proxiedInterfaces) {
 		return jdkProxyHint -> assertThat(jdkProxyHint.getProxiedInterfaces())
-				.containsExactly(toTypeReferences(proxiedInterfaces));
+				.containsExactlyElementsOf(TypeReference.listOf(proxiedInterfaces));
 	}
 
 	private static TypeReference[] toTypeReferences(String... proxiedInterfaces) {
 		return Arrays.stream(proxiedInterfaces).map(TypeReference::of).toArray(TypeReference[]::new);
 	}
 
-	private static TypeReference[] toTypeReferences(Class<?>... proxiedInterfaces) {
-		return Arrays.stream(proxiedInterfaces).map(TypeReference::of).toArray(TypeReference[]::new);
-	}
-
 
 	sealed interface SealedInterface {
 	}