Merge branch 'master' into method-type-param

Author: haewiful

AGENTS.md

@@ -0,0 +1,10 @@
+# Testing
+
+To run only the tests for the main NullAway module, run `./gradlew :nullaway:test`. Run _only_ these tests unless you
+are specifically asked to run a test in a different module. If you want to run a single
+test class or method within that module, you can use the `--tests` flag. For example, to run all tests in the
+`com.uber.nullaway.NullAwayTest` class, you would run:
+
+```bash
+./gradlew :nullaway:test --tests "com.uber.nullaway.NullAwayTest"
+```

CHANGELOG.md

@@ -1,6 +1,52 @@
 Changelog
 =========
 
+Version 0.12.14
+---------------
+
+This release fixes a bug where the new `RequireExplicitNullMarking` check was not fully disabled by default.  It also includes a couple of performance optimizations to reduce NullAway overhead.
+
+* Various optimizations (#1358)
+* Don't report matches from RequireExplicitNullMarking when run at SUGGESTION level (#1365)
+* Optimize methods that check for annotations on a Symbol (#1362)
+* Tune warning message for RequireExplicitNullMarking (#1366)
+* Maintenance
+  - Fix arg concatenation bug in JMH (#1357)
+  - Move wildcard-related tests to a separate test class (#1361)
+
+Version 0.12.13
+---------------
+
+NullAway now includes a new Error Prone checker, `RequireExplicitNullMarking`,
+that checks that every class is explicitly `@NullMarked` or `@NullUnmarked` (at the class or package level), so code
+is not left `@NullUnmarked` unintentionally.  The check is disabled by default.  See [the docs](https://github.com/uber/NullAway/wiki/JSpecify-Support#requireexplicitnullmarking-checker)
+for further details.
+
+NullAway also includes support for a new `@PureExceptLambda` annotation, contributed by @FxMorin, to tell NullAway
+to preserve nullability information from the enclosing method when analyzing the body of certain lambdas.
+See [the docs](https://github.com/uber/NullAway/wiki/Supported-Annotations#pureexceptlambda) for details.
+
+* Use passed-in `TreePath` in one more place when available (#1329)
+* Checker to ensure explicit null marking of every class (#1323)
+* Bound size of alreadyRunAnalyses cache to be consistent (#1334)
+* Improve inference for generic methods with lambda argument containing return statements by @dhruv-agr (#1337)
+* Add `PureExceptLambda` annotation by @FxMorin (#1325)
+* Support marking method type variable upper bounds as `@Nullable` in library models (#1345)
+* Method name parsing in `ExternalStubxLibraryModels` class is missing a corner case by @haewiful (#1344)
+* Better fix for dataflow analysis caching (#1353)
+* Maintenance
+    - Add package-info files with @NullMarked (#1331)
+    - Speed up buildWithNullAway task (#1330)
+    - Enable the VoidMissingNullable checker and autofix all extant warnings (#1332)
+    - Bump JDK version to 25 for integration tests (#1336)
+    - Switch Coderabbit to assertive mode (#1338)
+    - Enable EqualsMissingNullable check and fix all extant warnings (#1339)
+    - Bump to AutoValue 1.11.1 (#1340)
+    - Update Caffeine benchmark (#1342)
+    - Add a test for a useless @Contract (#1346)
+    - Test case for wildcards in Generic Method with Lambda Arguments by @dhruv-agr (#1349)
+    - Add initial AGENTS.md file (#1352)
+
 Version 0.12.12
 ---------------
 

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

gradle.properties

@@ -12,7 +12,7 @@ org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m
 
 GROUP=com.uber.nullaway
-VERSION_NAME=0.12.13-SNAPSHOT
+VERSION_NAME=0.12.15-SNAPSHOT
 
 POM_DESCRIPTION=A fast annotation-based null checker for Java
 

gradle/dependencies.gradle

@@ -83,7 +83,7 @@ def build = [
     errorProneTestHelpersOld: "com.google.errorprone:error_prone_test_helpers:${oldestErrorProneVersion}",
     checkerDataflow         : "org.checkerframework:dataflow-nullaway:${versions.checkerFramework}",
     gson                    : "com.google.code.gson:gson:2.13.1",
-    guava                   : "com.google.guava:guava:30.1-jre",
+    guava                   : "com.google.guava:guava:31.1-jre",
     javaparser              : "com.github.javaparser:javaparser-core:${versions.javaparser}",
     javaparserSymbolSolver  : "com.github.javaparser:javaparser-symbol-solver-core:${versions.javaparser}",
     javaxValidation         : "javax.validation:validation-api:2.0.1.Final",

guava-recent-unit-tests/build.gradle

@@ -39,6 +39,7 @@ dependencies {
     errorProneOldest(deps.build.errorProneTestHelpersOld) {
         exclude group: "junit", module: "junit"
     }
+    errorProneOldest deps.build.guava
 }
 
 // Create a task to test with the oldest supported version of Error Prone

jmh/src/main/java/com/uber/nullaway/jmh/NullawayJavac.java

@@ -30,7 +30,6 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import javax.tools.DiagnosticListener;
@@ -175,25 +174,33 @@ private NullawayJavac(
     outputDir.toFile().deleteOnExit();
     this.options = new ArrayList<>();
     if (classpath != null) {
-      options.addAll(Arrays.asList("-classpath", classpath));
+      options.addAll(List.of("-classpath", classpath));
     }
     String processorPath =
         System.getProperty("java.class.path") + File.pathSeparator + extraProcessorPath;
+    // Error Prone arguments must be passed space separated with -Xplugin:ErrorProne
+    String allErrorProneArgs =
+        String.join(
+            " ",
+            List.of(
+                "-Xplugin:ErrorProne",
+                "-XepDisableAllChecks",
+                "-Xep:NullAway:ERROR",
+                "-XepOpt:NullAway:AnnotatedPackages=" + annotatedPackages,
+                String.join(" ", extraErrorProneArgs)));
     options.addAll(
-        Arrays.asList(
+        List.of(
             "-processorpath",
             processorPath,
             "-d",
             outputDir.toAbsolutePath().toString(),
             "-XDcompilePolicy=simple",
             "--should-stop=ifError=FLOW",
-            "-Xplugin:ErrorProne -XepDisableAllChecks -Xep:NullAway:ERROR -XepOpt:NullAway:AnnotatedPackages="
-                + annotatedPackages
-                + String.join(" ", extraErrorProneArgs)));
+            allErrorProneArgs));
     // add these options since we have at least one benchmark that only compiles with access to
     // javac-internal APIs
     options.addAll(
-        Arrays.asList(
+        List.of(
             "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
             "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
             "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
@@ -205,6 +212,8 @@ private NullawayJavac(
             "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
             "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
             "--add-exports=jdk.compiler/com.sun.source.tree=ALL-UNNAMED"));
+    // for JSpecify mode (benign outside JSpecify mode)
+    options.add("-XDaddTypeAnnotationsToSymbol=true");
   }
 
   /**

nullaway/build.gradle

@@ -81,6 +81,7 @@ dependencies {
     errorProneOldest(deps.build.errorProneTestHelpersOld) {
         exclude group: "junit", module: "junit"
     }
+    errorProneOldest deps.build.guava
 }
 
 javadoc {

nullaway/src/main/java/com/uber/nullaway/NullabilityUtil.java

@@ -53,6 +53,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiPredicate;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import javax.lang.model.element.AnnotationMirror;
@@ -191,6 +192,37 @@ public static Stream<? extends AnnotationMirror> getAllAnnotations(Symbol symbol
     return Stream.concat(symbol.getAnnotationMirrors().stream(), typeUseAnnotations);
   }
 
+  /**
+   * Check if any direct annotation a symbol matches a given predicate. Works for both source and
+   * bytecode.
+   *
+   * @param symbol the symbol
+   * @param config NullAway configuration
+   * @param predicate the predicate to match annotation names against
+   * @return true if any annotation on the symbol matches the predicate, false otherwise
+   */
+  public static boolean hasAnyAnnotationMatching(
+      Symbol symbol, Config config, Predicate<String> predicate) {
+    for (AnnotationMirror annotationMirror : symbol.getAnnotationMirrors()) {
+      if (predicate.test(annotationMirror.getAnnotationType().toString())) {
+        return true;
+      }
+    }
+    // to handle bytecodes, also check direct type-use annotations stored in attributes
+    Symbol typeAnnotationOwner =
+        symbol.getKind().equals(ElementKind.PARAMETER) ? symbol.owner : symbol;
+    for (Attribute.TypeCompound typeCompound : typeAnnotationOwner.getRawTypeAttributes()) {
+      if (!targetTypeMatches(symbol, typeCompound.position)
+          || !isDirectTypeUseAnnotation(typeCompound, symbol, config)) {
+        continue;
+      }
+      if (predicate.test(typeCompound.getAnnotationType().toString())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Retrieve the {@code value} attribute of a method annotation of some type.
    *

nullaway/src/main/java/com/uber/nullaway/Nullness.java

@@ -68,15 +68,10 @@ public static boolean isMonotonicNonNullAnnotation(String annotName) {
    * {@code symbol}. Used to reason whether a field may be null.
    */
   public static boolean hasNullableOrMonotonicNonNullAnnotation(Symbol symbol, Config config) {
-    return hasNullableOrMonotonicNonNullAnnotation(
-        NullabilityUtil.getAllAnnotations(symbol, config), config);
-  }
-
-  private static boolean hasNullableOrMonotonicNonNullAnnotation(
-      Stream<? extends AnnotationMirror> annotations, Config config) {
-    return annotations
-        .map(anno -> anno.getAnnotationType().toString())
-        .anyMatch(anno -> isNullableAnnotation(anno, config) || isMonotonicNonNullAnnotation(anno));
+    return NullabilityUtil.hasAnyAnnotationMatching(
+        symbol,
+        config,
+        annot -> isNullableAnnotation(annot, config) || isMonotonicNonNullAnnotation(annot));
   }
 
   // The following leastUpperBound and greatestLowerBound methods were created by handwriting a
@@ -219,7 +214,8 @@ public static boolean isNonNullAnnotation(String annotName, Config config) {
    * Config)}
    */
   public static boolean hasNonNullAnnotation(Symbol symbol, Config config) {
-    return hasNonNullAnnotation(NullabilityUtil.getAllAnnotations(symbol, config), config);
+    return NullabilityUtil.hasAnyAnnotationMatching(
+        symbol, config, annot -> isNonNullAnnotation(annot, config));
   }
 
   /**
@@ -230,7 +226,8 @@ public static boolean hasNonNullAnnotation(Symbol symbol, Config config) {
    * Config)}
    */
   public static boolean hasNullableAnnotation(Symbol symbol, Config config) {
-    return hasNullableAnnotation(NullabilityUtil.getAllAnnotations(symbol, config), config);
+    return NullabilityUtil.hasAnyAnnotationMatching(
+        symbol, config, annot -> isNullableAnnotation(annot, config));
   }
 
   private static boolean hasNullableTypeUseAnnotation(Symbol symbol, Config config) {
@@ -316,11 +313,21 @@ public static boolean varargsArrayIsNullable(Symbol paramSymbol, Config config)
 
   /** Checks if the symbol has a {@code @Nullable} declaration annotation */
   public static boolean hasNullableDeclarationAnnotation(Symbol symbol, Config config) {
-    return hasNullableAnnotation(symbol.getRawAttributes().stream(), config);
+    for (AnnotationMirror annotationMirror : symbol.getRawAttributes()) {
+      if (isNullableAnnotation(annotationMirror.getAnnotationType().toString(), config)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   /** Checks if the symbol has a {@code @NonNull} declaration annotation */
   public static boolean hasNonNullDeclarationAnnotation(Symbol symbol, Config config) {
-    return hasNonNullAnnotation(symbol.getRawAttributes().stream(), config);
+    for (AnnotationMirror annotationMirror : symbol.getRawAttributes()) {
+      if (isNonNullAnnotation(annotationMirror.getAnnotationType().toString(), config)) {
+        return true;
+      }
+    }
+    return false;
   }
 }