Check for @NullMarked on packages

Projects which don't have JSpecify nullability annotations can opt out
by using

architectureCheck {
	nullMarked = false
}

in their build.gradle script.

See spring-projectsgh-46587

Author: mhalbritter

buildSrc/src/main/java/org/springframework/boot/build/architecture/ArchitectureCheck.java

@@ -25,11 +25,14 @@
 import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
+import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.core.domain.JavaClasses;
 import com.tngtech.archunit.core.importer.ClassFileImporter;
 import com.tngtech.archunit.lang.ArchRule;
@@ -100,6 +103,7 @@ private List<String> asDescriptions(List<ArchRule> rules) {
 	void checkArchitecture() throws Exception {
 		withCompileClasspath(() -> {
 			JavaClasses javaClasses = new ClassFileImporter().importPaths(classFilesPaths());
+			checkNullMarkedAnnotation(javaClasses);
 			List<EvaluationResult> violations = evaluate(javaClasses).filter(EvaluationResult::hasViolation).toList();
 			File outputFile = getOutputDirectory().file("failure-report.txt").get().getAsFile();
 			writeViolationReport(violations, outputFile);
@@ -110,6 +114,30 @@ void checkArchitecture() throws Exception {
 		});
 	}
 
+	private void checkNullMarkedAnnotation(JavaClasses javaClasses) {
+		if (!shouldCheckNullMarked()) {
+			return;
+		}
+		Set<String> unmarkedPackages = new HashSet<>();
+		for (JavaClass javaClass : javaClasses) {
+			if (!javaClass.getPackage().isAnnotatedWith("org.jspecify.annotations.NullMarked")) {
+				String packageName = javaClass.getPackage().getName();
+				unmarkedPackages.add(packageName);
+			}
+		}
+		if (!unmarkedPackages.isEmpty()) {
+			StringBuilder builder = new StringBuilder("Packages missing @NullMarked found:\n\n");
+			for (String unmarkedPackage : unmarkedPackages) {
+				builder.append("- ").append(unmarkedPackage).append("\n");
+			}
+			throw new VerificationException(builder.toString());
+		}
+	}
+
+	private boolean shouldCheckNullMarked() {
+		return getNullMarked().get();
+	}
+
 	private List<Path> classFilesPaths() {
 		return this.classes.getFiles().stream().map(File::toPath).toList();
 	}
@@ -186,4 +214,7 @@ final FileTree getInputClasses() {
 	@Input // Use descriptions as input since rules aren't serializable
 	abstract ListProperty<String> getRuleDescriptions();
 
+	@Internal
+	abstract Property<Boolean> getNullMarked();
+
 }

buildSrc/src/main/java/org/springframework/boot/build/architecture/ArchitectureCheckExtension.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2012-present 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.boot.build.architecture;
+
+import org.gradle.api.provider.Property;
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Extension to configure the {@link ArchitecturePlugin}.
+ *
+ * @author Moritz Halbritter
+ */
+public abstract class ArchitectureCheckExtension {
+
+	/**
+	 * Whether this project uses JSpecify's {@link NullMarked} annotations.
+	 * @return whether this project uses JSpecify's @NullMarked annotations
+	 */
+	public abstract Property<Boolean> getNullMarked();
+
+}

buildSrc/src/main/java/org/springframework/boot/build/architecture/ArchitecturePlugin.java

@@ -24,6 +24,7 @@
 import org.gradle.api.Task;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
+import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.language.base.plugins.LifecycleBasePlugin;
@@ -39,10 +40,12 @@ public class ArchitecturePlugin implements Plugin<Project> {
 
 	@Override
 	public void apply(Project project) {
-		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> registerTasks(project));
+		ArchitectureCheckExtension extension = project.getExtensions()
+			.create("architectureCheck", ArchitectureCheckExtension.class);
+		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> registerTasks(project, extension));
 	}
 
-	private void registerTasks(Project project) {
+	private void registerTasks(Project project, ArchitectureCheckExtension extension) {
 		JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
 		List<TaskProvider<ArchitectureCheck>> packageTangleChecks = new ArrayList<>();
 		for (SourceSet sourceSet : javaPluginExtension.getSourceSets()) {
@@ -57,6 +60,7 @@ private void registerTasks(Project project) {
 							task.setDescription("Checks the architecture of the classes of the " + sourceSet.getName()
 									+ " source set.");
 							task.setGroup(LifecycleBasePlugin.VERIFICATION_GROUP);
+							task.getNullMarked().set(checkNullMarked(sourceSet, extension));
 						});
 			packageTangleChecks.add(checkPackageTangles);
 		}
@@ -66,4 +70,9 @@ private void registerTasks(Project project) {
 		}
 	}
 
+	private Provider<Boolean> checkNullMarked(SourceSet sourceSet, ArchitectureCheckExtension extension) {
+		// Default to true only on main source set
+		return extension.getNullMarked().orElse(sourceSet.getName().equals(SourceSet.MAIN_SOURCE_SET_NAME));
+	}
+
 }

buildSrc/src/test/java/org/springframework/boot/build/architecture/ArchitectureCheckTests.java

@@ -193,6 +193,9 @@ void whenBeanPostProcessorBeanMethodIsNotStaticWithExternalClass() throws IOExce
 				dependencies {
 					implementation("org.springframework.integration:spring-integration-jmx:6.3.9")
 				}
+				architectureCheck {
+					nullMarked = false
+				}
 				""");
 		Path testClass = this.projectDir.resolve("src/main/java/boot/architecture/bpp/external/TestClass.java");
 		Files.createDirectories(testClass.getParent());
@@ -246,6 +249,9 @@ private void runGradleWithCompiledClasses(String path, Consumer<GradleRunner> ca
 						  output.classesDirs.setFrom(file("classes"))
 					  }
 				}
+				architectureCheck {
+					nullMarked = false
+				}
 				""");
 		runGradle(callback);
 	}

configuration-metadata/spring-boot-configuration-metadata-changelog-generator/build.gradle

@@ -38,6 +38,10 @@ dependencies {
 	testImplementation("org.junit.jupiter:junit-jupiter")
 }
 
+architectureCheck {
+	nullMarked = false
+}
+
 def dependenciesOf(String version) {
 	if (version.startsWith("4.")) {
 		return [

configuration-metadata/spring-boot-configuration-metadata/build.gradle

@@ -28,3 +28,7 @@ dependencies {
 	testImplementation("org.assertj:assertj-core")
 	testImplementation("org.springframework:spring-core")
 }
+
+architectureCheck {
+	nullMarked = false
+}

configuration-metadata/spring-boot-configuration-processor/build.gradle

@@ -30,6 +30,10 @@ sourceSets {
 	}
 }
 
+architectureCheck {
+	nullMarked = false
+}
+
 dependencies {
 	testCompileOnly("com.google.code.findbugs:jsr305:3.0.2")
 

core/spring-boot-autoconfigure-processor/build.gradle

@@ -26,3 +26,7 @@ dependencies {
 	testImplementation(enforcedPlatform(project(":platform:spring-boot-dependencies")))
 	testImplementation(project(":test-support:spring-boot-test-support"))
 }
+
+architectureCheck {
+	nullMarked = false
+}

documentation/spring-boot-docs/build.gradle

@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
+
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
+
 import org.springframework.boot.build.docs.ConfigureJavadocLinks
 
 plugins {
@@ -67,6 +69,10 @@ tasks.named('compileKotlin', KotlinCompilationTask.class) {
     javaSources.from = []
 }
 
+architectureCheck {
+	nullMarked = false
+}
+
 plugins.withType(EclipsePlugin) {
 	eclipse.classpath { classpath ->
 		classpath.plusConfigurations.add(configurations.getByName(sourceSets.main.runtimeClasspathConfigurationName))

loader/spring-boot-loader-classic/build.gradle

@@ -36,3 +36,7 @@ tasks.configureEach {
 		prohibitObjectsRequireNonNull = false
 	}
 }
+
+architectureCheck {
+	nullMarked = false
+}