Add nullaway and jSpecify for nullness analysis

Author: mikosik

.idea/inspectionProfiles/Project_Default.xml

@@ -34,7 +34,7 @@ subprojects { subproject ->
             'cli',
             'standard-library',
             'system-test']) {
-        apply plugin: 'java'
+        apply plugin: 'java-library'
         java {
             toolchain {
                 languageVersion = JavaLanguageVersion.of(25)
@@ -51,10 +51,18 @@ subprojects { subproject ->
         apply plugin: 'net.ltgt.errorprone'
         dependencies {
             errorprone "com.google.errorprone:error_prone_core:2.42.0"
+            api libs.jspecify
+            errorprone 'com.uber.nullaway:nullaway:0.12.9'
         }
         tasks.withType(JavaCompile).configureEach {
             options.errorprone {
                 disableWarningsInGeneratedCode.set(true)
+                option('NullAway:AnnotatedPackages', 'org.smoothbuild')
+                // Avoid errors when field is injected by picocli.
+                // In some cases, when picocli does not always inject some field
+                // (for example user is not required to provide some option in commandline),
+                // such field is annotated in code with @Nullable.
+                option('NullAway:ExternalInitAnnotations', 'picocli.CommandLine.Command')
             }
         }
 

build.gradle

@@ -23,6 +23,7 @@ dependencyResolutionManagement {
       library('antlr4', 'org.antlr:antlr4:4.13.2')
       library('antlr4-runtime', 'org.antlr:antlr4-runtime:4.13.2')
       library('guava', 'com.google.guava:guava:33.5.0-jre')
+      library('jspecify', 'org.jspecify:jspecify:1.0.0')
       library('dagger', 'com.google.dagger:dagger:2.57.2')
       library('dagger-compiler', 'com.google.dagger:dagger-compiler:2.57.2')
       library('okio', 'com.squareup.okio:okio:3.16.0')

settings.gradle

@@ -9,6 +9,7 @@
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 import org.smoothbuild.cli.layout.Layout;
+import org.smoothbuild.common.collect.Result;
 
 public abstract class ProjectCommand extends LoggingCommand implements Callable<Integer> {
   @Override
@@ -21,15 +22,17 @@ public Integer call() {
       return EXIT_CODE_ERROR;
     }
     Path normalizedProjectDir = projectDir.normalize();
-    FileLock fileLock = lockFile(out(), projectDir.resolve(Layout.SMOOTH_LOCK_PATH.toString()));
-    if (fileLock == null) {
+    Result<FileLock> lockFile =
+        lockFile(out(), projectDir.resolve(Layout.SMOOTH_LOCK_PATH.toString()));
+    if (lockFile.isErr()) {
+      printError(lockFile.err());
       return EXIT_CODE_ERROR;
     }
     try {
       return executeCommand(normalizedProjectDir);
     } finally {
       try {
-        fileLock.release();
+        lockFile.ok().release();
       } catch (IOException e) {
         printError("Error closing file lock.");
         return EXIT_CODE_ERROR;

src/cli/src/main/java/org/smoothbuild/cli/command/base/ProjectCommand.java

@@ -1,5 +1,6 @@
 package org.smoothbuild.cli.command.build;
 
+import static org.smoothbuild.common.base.Throwables.messageFrom;
 import static org.smoothbuild.common.log.base.Log.error;
 import static org.smoothbuild.common.log.report.Report.report;
 import static org.smoothbuild.common.schedule.Output.output;
@@ -31,7 +32,7 @@ public Output<Tuple0> execute() {
       fileSystem.deleteRecursively(artifactsPath);
       return output(tuple(), report(label));
     } catch (IOException e) {
-      return output(report(label, error(e.getMessage())));
+      return output(report(label, error(messageFrom(e))));
     }
   }
 }

src/cli/src/main/java/org/smoothbuild/cli/command/build/DeleteArtifacts.java

@@ -2,7 +2,9 @@
 
 import static com.google.common.base.Throwables.getStackTraceAsString;
 import static java.util.Comparator.comparing;
+import static java.util.Objects.requireNonNullElse;
 import static java.util.stream.Collectors.joining;
+import static org.smoothbuild.common.base.Throwables.messageFrom;
 import static org.smoothbuild.common.collect.List.list;
 import static org.smoothbuild.common.filesystem.base.Path.path;
 import static org.smoothbuild.common.log.base.Log.error;
@@ -65,7 +67,7 @@ public Output<Tuple0> execute(EvaluatedExprs evaluatedExprs) {
     try {
       fileSystem.createDir(artifactsPath);
     } catch (IOException e) {
-      return output(report(label, error(e.getMessage())));
+      return output(report(label, error(messageFrom(e))));
     }
     var sReferences = evaluatedExprs.sExprs().map(this::toReferenceS);
     var artifacts = sReferences.zip(evaluatedExprs.bValues(), Tuples::tuple);
@@ -77,7 +79,7 @@ public Output<Tuple0> execute(EvaluatedExprs evaluatedExprs) {
   }
 
   private SPolyReference toReferenceS(SExpr expr) {
-    return (SPolyReference) ((SInstantiate) expr).sPolyReference();
+    return ((SInstantiate) expr).sPolyReference();
   }
 
   private void save(SPolyReference valueS, BValue value, Logger logger) {
@@ -89,7 +91,7 @@ private void save(SPolyReference valueS, BValue value, Logger logger) {
       logger.fatal("Couldn't store artifact at " + artifactPath(name) + ". Caught exception:\n"
           + getStackTraceAsString(e));
     } catch (DuplicatedPathsException e) {
-      logger.error(e.getMessage());
+      logger.error(requireNonNullElse(e.getMessage(), "DuplicatePathsException"));
     }
   }
 

src/cli/src/main/java/org/smoothbuild/cli/command/build/SaveArtifacts.java

@@ -3,6 +3,7 @@ plugins {
 }
 
 dependencies {
+    api libs.jspecify
     implementation libs.truth
 
     testRuntimeOnly libs.junit.jupiter.engine

src/common-testing/build.gradle

@@ -4,19 +4,22 @@
 import static com.google.common.truth.Fact.simpleFact;
 import static com.google.common.truth.Truth.assertAbout;
 import static java.util.Arrays.asList;
+import static java.util.Objects.requireNonNull;
 
 import com.google.common.truth.Fact;
 import com.google.common.truth.FailureMetadata;
 import com.google.common.truth.Subject;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import org.jspecify.annotations.Nullable;
 
 public class AssertCall {
   public static ThrownExceptionSubject assertCall(ThrowingRunnable runnable) {
     return assertAbout(thrownExceptions()).that(runRunnable(runnable));
   }
 
+  @Nullable
   private static Throwable runRunnable(ThrowingRunnable runnable) {
     try {
       runnable.run();
@@ -31,10 +34,12 @@ private static Subject.Factory<ThrownExceptionSubject, Throwable> thrownExceptio
   }
 
   public static class ThrownExceptionSubject extends Subject {
-    private final Object actual;
+    private final FailureMetadata metadata;
+    private final @Nullable Object actual;
 
-    public ThrownExceptionSubject(FailureMetadata metadata, Object actual) {
+    public ThrownExceptionSubject(FailureMetadata metadata, @Nullable Object actual) {
       super(metadata, actual);
+      this.metadata = metadata;
       this.actual = actual;
     }
 
@@ -56,9 +61,13 @@ public ExceptionCauseSubject throwsException(Throwable expected) {
               fact("but was message", actualMessage));
         }
       }
-      return new ExceptionCauseSubject(List.of(
-          fact("expected call to throw", expectedClassName),
-          fact("with message", ((Throwable) actual).getMessage())));
+      var nonNullActual = requireNonNull(actual);
+      return new ExceptionCauseSubject(
+          metadata,
+          nonNullActual,
+          List.of(
+              fact("expected call to throw", expectedClassName),
+              fact("with message", expected.getMessage())));
     }
 
     public ExceptionCauseSubject throwsException(Class<? extends Throwable> expected) {
@@ -69,62 +78,68 @@ public ExceptionCauseSubject throwsException(Class<? extends Throwable> expected
       } else if (actual.getClass() != expected) {
         failWithActual(fact("expected call to throw", expected.getCanonicalName()));
       }
+      var nonNullActual = requireNonNull(actual);
       return new ExceptionCauseSubject(
+          metadata,
+          nonNullActual,
           List.of(fact("expected call to throw", expected.getCanonicalName())));
     }
+  }
 
-    public class ExceptionCauseSubject {
-      private final List<Fact> facts;
+  public static class ExceptionCauseSubject extends Subject {
+    private final Object actual;
+    private final List<Fact> facts;
 
-      public ExceptionCauseSubject(List<Fact> facts) {
-        this.facts = facts;
-      }
+    public ExceptionCauseSubject(FailureMetadata metadata, Object actual, List<Fact> facts) {
+      super(metadata, actual);
+      this.actual = actual;
+      this.facts = facts;
+    }
 
-      public void withCause(Throwable expectedCause) {
-        Throwable actualCause = ((Throwable) actual).getCause();
-        String expectedCauseName = expectedCause.getClass().getCanonicalName();
-        if (actualCause == null) {
-          callFailWithoutActual(
-              facts,
-              fact("with cause", expectedCauseName),
-              simpleFact("but was exception without cause"));
-        } else if (!Objects.equals(actualCause.getClass(), expectedCause.getClass())) {
-          callFailWithoutActual(
-              facts,
-              fact("with cause", expectedCauseName),
-              fact("but was cause", actualCause.getClass().getCanonicalName()));
-        } else if (!Objects.equals(actualCause.getMessage(), expectedCause.getMessage())) {
-          callFailWithoutActual(
-              facts,
-              fact("with cause", expectedCauseName),
-              fact("with message", expectedCause.getMessage()),
-              fact("but was message", actualCause.getMessage()));
-        }
+    public void withCause(Throwable expectedCause) {
+      Throwable actualCause = ((Throwable) actual).getCause();
+      String expectedCauseName = expectedCause.getClass().getCanonicalName();
+      if (actualCause == null) {
+        callFailWithoutActual(
+            facts,
+            fact("with cause", expectedCauseName),
+            simpleFact("but was exception without cause"));
+      } else if (!Objects.equals(actualCause.getClass(), expectedCause.getClass())) {
+        callFailWithoutActual(
+            facts,
+            fact("with cause", expectedCauseName),
+            fact("but was cause", actualCause.getClass().getCanonicalName()));
+      } else if (!Objects.equals(actualCause.getMessage(), expectedCause.getMessage())) {
+        callFailWithoutActual(
+            facts,
+            fact("with cause", expectedCauseName),
+            fact("with message", expectedCause.getMessage()),
+            fact("but was message", actualCause.getMessage()));
       }
+    }
 
-      public void withCause(Class<? extends Throwable> expectedCause) {
-        Throwable actualCause = ((Throwable) actual).getCause();
-        String expectedCauseName = expectedCause.getCanonicalName();
-        if (actualCause == null) {
-          callFailWithoutActual(
-              facts,
-              fact("with cause", expectedCauseName),
-              simpleFact("but was exception without cause"));
-        } else if (!actualCause.getClass().equals(expectedCause)) {
-          callFailWithoutActual(
-              facts,
-              fact("with cause", expectedCauseName),
-              fact("but was cause", actualCause.getClass().getCanonicalName()));
-        }
+    public void withCause(Class<? extends Throwable> expectedCause) {
+      Throwable actualCause = ((Throwable) actual).getCause();
+      String expectedCauseName = expectedCause.getCanonicalName();
+      if (actualCause == null) {
+        callFailWithoutActual(
+            facts,
+            fact("with cause", expectedCauseName),
+            simpleFact("but was exception without cause"));
+      } else if (!actualCause.getClass().equals(expectedCause)) {
+        callFailWithoutActual(
+            facts,
+            fact("with cause", expectedCauseName),
+            fact("but was cause", actualCause.getClass().getCanonicalName()));
       }
+    }
 
-      private void callFailWithoutActual(List<Fact> facts1, Fact... facts2) {
-        Fact first = facts1.get(0);
-        ArrayList<Fact> allWithoutFirst = new ArrayList<>();
-        allWithoutFirst.addAll(facts1.subList(1, facts1.size()));
-        allWithoutFirst.addAll(asList(facts2));
-        failWithoutActual(first, allWithoutFirst.toArray(Fact[]::new));
-      }
+    private void callFailWithoutActual(List<Fact> facts1, Fact... facts2) {
+      Fact first = facts1.get(0);
+      ArrayList<Fact> allWithoutFirst = new ArrayList<>();
+      allWithoutFirst.addAll(facts1.subList(1, facts1.size()));
+      allWithoutFirst.addAll(asList(facts2));
+      failWithoutActual(first, allWithoutFirst.toArray(Fact[]::new));
     }
   }
 }

src/common-testing/src/main/java/org/smoothbuild/commontesting/AssertCall.java

@@ -4,6 +4,7 @@ plugins {
 }
 
 dependencies {
+    api libs.jspecify
     implementation libs.guava
     implementation libs.dagger
     annotationProcessor libs.dagger.compiler

src/common/build.gradle

@@ -2,8 +2,10 @@
 
 import static java.util.Objects.requireNonNull;
 
+import org.jspecify.annotations.Nullable;
+
 public class Check {
-  public static <T> T checkInitializedToNotNull(T value, String name) {
+  public static <T> T checkInitializedToNotNull(@Nullable T value, String name) {
     return requireNonNull(value, Strings.q(name) + " has not been initialized yet.");
   }
 }