applying errorprone and nullaway for jst

Author: svene

jst/build.gradle

@@ -2,6 +2,7 @@ plugins {
 	id 'buildlogic.java-library-conventions'
 	alias(libs.plugins.versions)
 	id "org.xcommand.javacc"
+	alias(libs.plugins.errorprone)
 }
 
 javacc {
@@ -10,6 +11,24 @@ javacc {
 }
 compileJava.dependsOn(jcc)
 
+import net.ltgt.gradle.errorprone.CheckSeverity
+tasks.withType(JavaCompile) {
+	options.errorprone {
+		//disableAllChecks
+		check("NullAway", CheckSeverity.ERROR)
+		option("NullAway:AnnotatedPackages", "org.xcommand")
+		option("NullAway:ExcludedClassAnnotations", "javax.annotation.processing.Generated")
+		option("NullAway:KnownInitializers", "org.xcommand.web.WebCVInitializationFilter.init")
+		excludedPaths.set(".*/build/.*")
+	}
+	// Include to disable NullAway on test code
+	if (name.toLowerCase().contains("test")) {
+		options.errorprone {
+			disable("NullAway")
+		}
+	}
+}
+
 sourceSets {
 	main {
 		java {
@@ -18,6 +37,11 @@ sourceSets {
 	}
 }
 dependencies {
+	annotationProcessor libs.errorprone.core
+	errorprone libs.nullaway
+	api libs.jspecify
+	errorprone libs.errorprone.core
+
 	implementation project(':xc-core')
 	implementation libs.javacc
 	annotationProcessor libs.recordbuilder.processor

jst/src/main/java/org/xcommand/template/jst/CachingFilesSystemScanner.java

@@ -8,14 +8,12 @@
 import org.xcommand.util.FilesUnchecked;
 
 import java.util.HashMap;
+import java.util.List;
 
 public class CachingFilesSystemScanner implements ICommand {
 	@Override
 	public void execute() {
-		var rootPaths = fileSystemScannerCV.getRootPath();
-
-		var fssc = FileSystemScanner.newInstance();
-		fssc.setRootPaths(rootPaths);
+		var fssc = FileSystemScanner.newInstance(List.of(fileSystemScannerCV.getRootPath()));
 		fssc.getFileFoundNotifier().registerObserver(new FileFoundHandler());
 		var changedFiles = new HashMap<String, FileMapEntry>();
 		cachingFilesSystemScannerCV.setChangedFiles(changedFiles);

jst/src/main/java/org/xcommand/template/jst/DefaultJSTParserProvider.java

@@ -76,6 +76,7 @@ public void execute() {
 			code.append(v);
 		}
 	};
+	@SuppressWarnings("unused")
 	private final ICommand eolObserver = new ICommand() {
 		@Override
 		public void execute() {

jst/src/main/java/org/xcommand/template/jst/DefaultJSTRoutines.java

@@ -5,18 +5,21 @@
 
 import java.io.OutputStreamWriter;
 import java.io.Writer;
+import java.nio.charset.StandardCharsets;
 import java.util.Objects;
 
 public class DefaultJSTRoutines implements IJSTRoutines {
 	public void ensureExistenceOfWriter() {
-		TCP.getContext().computeIfAbsent("writer", s -> new OutputStreamWriter(System.out));
+		TCP.getContext().computeIfAbsent("writer", s -> new OutputStreamWriter(System.out, StandardCharsets.UTF_8));
 	}
 
+	@Override
 	public void $s(String aString) {
 		Objects.requireNonNull(aString, "aString");
 		writeToWriter(aString);
 	}
 
+	@Override
 	public void $v(String aName) {
 		Objects.requireNonNull(aName, "aName");
 		var value = (String) TCP.getContext().get(aName);
@@ -25,6 +28,8 @@ public void ensureExistenceOfWriter() {
 	}
 
 	private void writeToWriter(String aString) {
-		Sneaky.runnable(() -> ((Writer) TCP.getContext().get("writer")).write(aString)).run();
+		if (TCP.getContext().get("writer") instanceof Writer w) {
+			Sneaky.runnable(() -> w.write(aString)).run();
+		}
 	}
 }

jst/src/main/java/org/xcommand/template/jst/FileSystemBasedJSTProvider.java

@@ -6,17 +6,21 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 public class FileSystemBasedJSTProvider implements IJSTProvider {
 
 	@Override
-	public ClassMapEntry getClassMapEntry(Map aCtx, String aClassname) {
-		return classMap.get(aClassname);
+	public Optional<ClassMapEntry> getClassMapEntry(Map aCtx, String aClassname) {
+		if (!classMap.containsKey(aClassname)) {
+			return Optional.empty();
+		}
+		return Optional.ofNullable(classMap.get(aClassname));
 	}
 
 	@Override
 	public Map<String, ClassMapEntry> getClassMap() {
-		return null;
+		return Map.of();
 	}
 
 	public void setGenSourceDir(String aGenSourceDir) {
@@ -28,10 +32,12 @@ public INotifier getChangeNotifier() {
 		return changeNotifier;
 	}
 
-	private List srcDirs;
+	@SuppressWarnings("unused")
+	private List<String> srcDirs = List.of();
 	private final Map<String, ClassMapEntry> classMap = new HashMap<>();
 	private final INotifier changeNotifier = new BasicNotifier();
-	private String genSourceDir;
+	@SuppressWarnings("unused")
+	private String genSourceDir = "build";
 }
 
 

jst/src/main/java/org/xcommand/template/jst/FileSystemBasedJSTScanner.java

@@ -1,5 +1,6 @@
 package org.xcommand.template.jst;
 
+import org.jspecify.annotations.Nullable;
 import org.xcommand.core.DynaBeanProvider;
 import org.xcommand.core.ICommand;
 import org.xcommand.core.IDynaBeanProvider;
@@ -94,7 +95,7 @@ private String getClassnameFromFilename(Path aSrcDir, Path aAbsolutePath) {
 		}
 	}
 
-	private String genSourceDir;
+	private @Nullable String genSourceDir;
 	private final INotifier changeNotifier = new BasicNotifier();
 
 	private final IDynaBeanProvider dbp = DynaBeanProvider.newThreadClassMethodInstance();

jst/src/main/java/org/xcommand/template/jst/FileSystemScanner.java

@@ -16,8 +16,13 @@
 
 public final class FileSystemScanner implements ICommand, FileSystemScannerExt {
 
-	private FileSystemScanner(FileSystemScannerExt ext) {
-		this.ext = ext == null ? this : ext;
+	private FileSystemScanner(List<Path> rootPaths, FileSystemScannerExt ext) {
+		this.rootPaths = rootPaths;
+		this.ext = ext;
+	}
+	private FileSystemScanner(List<Path> rootPaths) {
+		this.rootPaths = rootPaths;
+		this.ext = this;
 	}
 
 	private final FileSystemScannerExt ext;
@@ -27,18 +32,17 @@ private FileSystemScanner(FileSystemScannerExt ext) {
 	private final IFileSystemScannerCV fileSystemScannerCV = dbp.newBeanForInterface(IFileSystemScannerCV.class);
 
 
-	public static FileSystemScanner newInstance() {
-		return new FileSystemScanner(null);
+	public static FileSystemScanner newInstance(List<Path> rootPaths) {
+		return new FileSystemScanner(rootPaths);
 	}
-	public static FileSystemScanner newInstance(FileSystemScannerExt relations) {
-		return new FileSystemScanner(relations);
+	public static FileSystemScanner newInstance(List<Path> rootPaths, FileSystemScannerExt relations) {
+		return new FileSystemScanner(rootPaths, relations);
 	}
 
 	@Override
 	public void execute() {
 		rootPaths.forEach(rootPath -> {
 			fileSystemScannerCV.setRootPath(rootPath);
-			boolean ex = Files.exists(rootPath);
 			FilesUnchecked.walkFileTree(rootPath, new SimpleFileVisitor<>() {
 				@Override
 				public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) {
@@ -59,10 +63,6 @@ public INotifier getFileFoundNotifier() {
 		return fileFoundNotifier;
 	}
 
-	public void setRootPaths(Path... aRootPaths) {
-		setRootPaths(List.of(aRootPaths));
-	}
-
 	public void setRootPaths(List<Path> aRootDirs) {
 		rootPaths = aRootDirs;
 	}

jst/src/main/java/org/xcommand/template/jst/FileSystemScannerExt.java

@@ -2,6 +2,7 @@
 
 import java.nio.file.Path;
 
+@FunctionalInterface
 public interface FileSystemScannerExt {
 	void handlePath(Path path);
 }

jst/src/main/java/org/xcommand/template/jst/IJSTProvider.java

@@ -3,9 +3,10 @@
 import org.xcommand.pattern.observer.INotifier;
 
 import java.util.Map;
+import java.util.Optional;
 
 public interface IJSTProvider {
-	ClassMapEntry getClassMapEntry(Map<String, Object> aCtx, String aClassname);
+	Optional<ClassMapEntry> getClassMapEntry(Map<String, Object> aCtx, String aClassname);
 
 	Map<String, ClassMapEntry> getClassMap();
 

jst/src/main/java/org/xcommand/template/jst/IUriToClassnameMapper.java

@@ -1,5 +1,6 @@
 package org.xcommand.template.jst;
 
+@FunctionalInterface
 public interface IUriToClassnameMapper {
 	String getClassnameForUri(String aURI);
 }