Introduce PrimiviteProvider to determine nullability definitions.

Author: mp911de

src/main/java/org/springframework/data/util/Nullability.java

@@ -62,6 +62,9 @@
  * 	}
  * }
  * </pre>
+ *
+ * Note that nullability is also expressed through using specific types. Primitives ({@code int}, {@code char} etc.) are
+ * non-nullable by definition and cannot be {@code null}. {@code void}/{@code Void} types are {@code null}-only types.
  * <p>
  * {@code javax.annotation.Nonnull} is suitable for composition of meta-annotations and expresses via
  * {@code javax.annotation.Nonnull#when()} in which cases non-nullability is applicable. Nullability introspection
@@ -270,6 +273,15 @@ default Nullability forReturnType() {
 		 */
 		Nullability forParameter(Parameter parameter);
 
+		/**
+		 * Returns a {@link Nullability} instance for a method parameter by index.
+		 *
+		 * @param index the method parameter index.
+		 * @return a {@link Nullability} instance for a method parameter.
+		 * @throws IndexOutOfBoundsException if the method parameter index is out of bounds.
+		 */
+		Nullability forParameter(int index);
+
 		/**
 		 * Returns a {@link Nullability} instance for a method parameter.
 		 *
@@ -281,6 +293,13 @@ default Nullability forParameter(MethodParameter parameter) {
 			return parameter.getParameterIndex() == -1 ? forReturnType() : forParameter(parameter.getParameter());
 		}
 
+		/**
+		 * Returns the method parameter count.
+		 *
+		 * @return the method parameter count.
+		 */
+		int getParameterCount();
+
 	}
 
 }

src/main/java/org/springframework/data/util/NullabilityIntrospector.java

@@ -53,7 +53,9 @@ class NullabilityIntrospector implements Nullability.Introspector {
 	private static final List<NullabilityProvider> providers;
 
 	static {
-		providers = new ArrayList<>(4);
+		providers = new ArrayList<>(5);
+
+		providers.add(new PrimitiveProvider());
 
 		if (Jsr305Provider.isAvailable()) {
 			providers.add(new Jsr305Provider());
@@ -202,6 +204,39 @@ static abstract class NullabilityProvider {
 		abstract Spec evaluate(AnnotatedElement element, ElementType elementType);
 	}
 
+	/**
+	 * Provider considering primitive types.
+	 */
+	static class PrimitiveProvider extends NullabilityProvider {
+
+		@Override
+		Spec evaluate(AnnotatedElement element, ElementType elementType) {
+
+			Class<?> type = null;
+
+			if (element instanceof Method m) {
+				type = m.getReturnType();
+			}
+
+			if (element instanceof Parameter p) {
+				type = p.getType();
+			}
+
+			if (type != null) {
+
+				if (ReflectionUtils.isVoid(type)) {
+					return Spec.NULLABLE;
+				}
+
+				if (type.isPrimitive()) {
+					return Spec.NON_NULL;
+				}
+			}
+
+			return Spec.UNSPECIFIED;
+		}
+	}
+
 	/**
 	 * Spring provider leveraging {@link NonNullApi @NonNullApi}, {@link NonNullFields @NonNullFields},
 	 * {@link NonNull @NonNull}, and {@link Nullable @Nullable} annotations.
@@ -515,6 +550,21 @@ public Nullability forParameter(Parameter parameter) {
 
 			return nullability;
 		}
+
+		@Override
+		public Nullability forParameter(int index) {
+
+			if (index >= method.getParameterCount() || index < 0) {
+				throw new IndexOutOfBoundsException();
+			}
+
+			return forParameter(method.getParameters()[index]);
+		}
+
+		@Override
+		public int getParameterCount() {
+			return method.getParameterCount();
+		}
 	}
 
 	/**

src/test/java/org/springframework/data/util/NullabilityUnitTests.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.util;
+
+import static org.assertj.core.api.Assertions.*;
+
+import java.lang.reflect.Method;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for {@link Nullability}.
+ *
+ * @author Mark Paluch
+ */
+class NullabilityUnitTests {
+
+	@Test
+	void shouldConsiderPrimitiveNullability() throws NoSuchMethodException {
+
+		Method method = getClass().getDeclaredMethod("someMethod", Integer.TYPE);
+		Nullability.MethodNullability methodNullability = Nullability.forMethod(method);
+
+		// method return type
+		assertThat(methodNullability.isDeclared()).isTrue();
+		assertThat(methodNullability.isNullable()).isTrue();
+
+		Nullability pn = methodNullability.forParameter(0);
+
+		// method return type
+		assertThat(pn.isDeclared()).isTrue();
+		assertThat(pn.isNullable()).isFalse();
+	}
+
+	void someMethod(int i) {
+
+	}
+}

src/test/java/org/springframework/data/util/nonnull/type/Jsr305NonnullAnnotatedType.java

@@ -23,6 +23,6 @@
 @Nonnull
 public interface Jsr305NonnullAnnotatedType {
 
-	void someMethod(String arg);
+	String someMethod(String arg);
 
 }

src/test/java/org/springframework/data/util/nonnull/type/NonAnnotatedType.java

@@ -20,8 +20,8 @@
  */
 public class NonAnnotatedType {
 
-	void someMethod(String arg){
-		return;
+	String someMethod(String arg) {
+		return "";
 	}
 
 }

src/test/java/org/springframework/data/util/nonnull/type/NonNullableParameters.java

@@ -23,5 +23,5 @@
 @ParametersAreNonnullByDefault
 public interface NonNullableParameters {
 
-	void someMethod(String arg);
+	String someMethod(String arg);
 }