issue 1275 - report unboxing warning for for-each loop (#1281)

The core of the solution is a new check that activates when the loop
variable is a primitive type
For arrays (e.g., @nullable Integer[]), the existing
NullabilityUtil.isArrayElementNullable utility is used to determine if
the elements can be null.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* New Features
* Adds a JSpecify-only check that flags unsafe auto-unboxing in enhanced
for-each loops over arrays when elements may be nullable and the loop
variable is primitive. Clear diagnostic provided. No impact outside
JSpecify mode.

* Tests
* Added tests covering nullable and non-null array elements in for-each
unboxing scenarios.
* Introduced a test-only Nullable annotation and additional cases
validating array element nullability behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Manu Sridharan <msridhar@gmail.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: 3 people

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

@@ -1852,6 +1852,30 @@ public Description matchEnhancedForLoop(EnhancedForLoopTree tree, VisitorState s
     if (mayBeNullExpr(state, expr)) {
       return errorBuilder.createErrorDescription(errorMessage, buildDescription(expr), state, null);
     }
+    // auto-unboxing check in JSpecify mode
+    if (!config.isJSpecifyMode()) {
+      return Description.NO_MATCH;
+    }
+
+    VariableTree loopVariable = tree.getVariable();
+    Type loopVariableType = ASTHelpers.getType(loopVariable);
+    // Only relevant when the loop variable is a primitive (implies unboxing of elements).
+    if (loopVariableType == null || !loopVariableType.isPrimitive()) {
+      return Description.NO_MATCH;
+    }
+    Type expressionType = ASTHelpers.getType(expr);
+    if (expressionType != null && expressionType.getKind() == TypeKind.ARRAY) {
+      Symbol arraySymbol = ASTHelpers.getSymbol(expr);
+      if (arraySymbol != null && isArrayElementNullable(arraySymbol, config)) {
+        // A nullable element is being unboxed to a primitive. This is unsafe.
+        ErrorMessage errorMessageUnbox =
+            new ErrorMessage(MessageTypes.UNBOX_NULLABLE, "unboxing of a @Nullable value");
+        state.reportMatch(
+            errorBuilder.createErrorDescription(
+                errorMessageUnbox, buildDescription(loopVariable), state, null));
+      }
+    }
+
     return Description.NO_MATCH;
   }
 

nullaway/src/test/java/com/uber/nullaway/jspecify/JSpecifyArrayTests.java

@@ -672,6 +672,37 @@ public void typeUseAndDeclarationAnnotationOnArray() {
         .doTest();
   }
 
+  @Test
+  public void unboxForEachLoop() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "import org.jspecify.annotations.*;",
+            "@NullMarked",
+            "class Test {",
+            "   void f(@Nullable Integer[] array) {",
+            "     // BUG: Diagnostic contains: unboxing of a @Nullable value",
+            "     for (int x : array) {}",
+            "   }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void unboxForEachLoopNonNull() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "import org.jspecify.annotations.*;",
+            "@NullMarked",
+            "class Test {",
+            "   void f(Integer[] array) {",
+            "     for (int x : array) {}",
+            "   }",
+            "}")
+        .doTest();
+  }
+
   private CompilationTestHelper makeHelper() {
     return makeTestHelperWithArgs(
         Arrays.asList(