Suppresses RLC non-final field overwrite warning for safe constructor field initialization

checker/src/test/java/org/checkerframework/checker/test/junit/ResourceLeakFirstInitConstructorTest.java

@@ -0,0 +1,32 @@
+package org.checkerframework.checker.test.junit;
+
+import java.io.File;
+import java.util.List;
+import org.checkerframework.checker.resourceleak.ResourceLeakChecker;
+import org.checkerframework.framework.test.CheckerFrameworkPerDirectoryTest;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Tests for validating safe suppression of resource leak warnings when a private field is
+ * initialized for the first time inside a constructor.
+ *
+ * <p>These tests check that the checker allows first-time constructor-based assignments (when safe)
+ * and continues to report reassignments or leaks in all other cases (e.g., after method calls,
+ * initializer blocks, etc.).
+ */
+public class ResourceLeakFirstInitConstructorTest extends CheckerFrameworkPerDirectoryTest {
+  public ResourceLeakFirstInitConstructorTest(List<File> testFiles) {
+    super(
+        testFiles,
+        ResourceLeakChecker.class,
+        "resourceleak-firstinitconstructor",
+        "-AwarnUnneededSuppressions",
+        "-encoding",
+        "UTF-8");
+  }
+
+  @Parameters
+  public static String[] getTestDirs() {
+    return new String[] {"resourceleak-firstinitconstructor"};
+  }
+}

checker/tests/resourceleak-firstinitconstructor/ConstructorChainingLeak.java

@@ -0,0 +1,38 @@
+// Test: Field is initialized in one constructor and reassigned in another via this() chaining.
+// Expected: Warning in constructor and open() due to reassignments.
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class ConstructorChainingLeak {
+  private @Owning FileInputStream s;
+
+  public ConstructorChainingLeak() throws Exception {
+    this(42);
+    // :: error: [required.method.not.called]
+    s = new FileInputStream("test.txt");
+  }
+
+  private ConstructorChainingLeak(int x) throws Exception {
+    s = new FileInputStream("test.txt");
+  }
+
+  // :: error: [missing.creates.mustcall.for]
+  public void open() {
+    try {
+      // :: error: [required.method.not.called]
+      s = new FileInputStream("test.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/ExplicitNullInitializer.java

@@ -0,0 +1,35 @@
+// Test: Field is explicitly initialized to null and assigned in constructor.
+// Expected: No warning in constructor, warning in open().
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class ExplicitNullInitializer {
+  private @Owning FileInputStream s = null;
+
+  public ExplicitNullInitializer() {
+    try {
+      s = new FileInputStream("test.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  // :: error: [missing.creates.mustcall.for]
+  public void open() {
+    try {
+      // :: error: [required.method.not.called]
+      s = new FileInputStream("test.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/FinalField.java

@@ -0,0 +1,27 @@
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class FinalField {
+  private int i;
+
+  private final @Owning FileInputStream s;
+
+  public FinalField() throws Exception {
+    havoc();
+    s = new FileInputStream("test.txt");
+  }
+
+  void havoc() {
+    i++;
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/FirstAssignmentInConditional.java

@@ -0,0 +1,63 @@
+// Demonstrates conservative behavior for assignments inside conditionals.
+//
+// Because the current analysis does not reason about control-flow branches,
+// each assignment inside an if/else is treated as a potential re-assignment
+// rather than the first write. As a result, every write below is reported,
+// even though each branch actually assigns the field only once.
+//
+// A CFG-aware implementation would recognize that only one branch executes
+// and would not warn on any of these assignments.
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class FirstAssignmentInConditional {
+  private @Owning FileInputStream s;
+
+  public FirstAssignmentInConditional(boolean b) {
+    try {
+      if (b) {
+        // ::error: [required.method.not.called]
+        s = new FileInputStream("test1.txt"); // false positive: first write in this branch
+      } else {
+        // ::error: [required.method.not.called]
+        s = new FileInputStream("test2.txt"); // false positive: first write in this branch
+      }
+    } catch (Exception e) {
+    }
+  }
+
+  public FirstAssignmentInConditional(boolean b1, boolean b2) {
+    try {
+      if (b1) {
+        if (b2) {
+          // ::error: [required.method.not.called]
+          s = new FileInputStream("test1.txt"); // false positive
+        } else {
+          // ::error: [required.method.not.called]
+          s = new FileInputStream("test2.txt"); // false positive
+        }
+      } else {
+        if (b2) {
+          // ::error: [required.method.not.called]
+          s = new FileInputStream("test1.txt"); // false positive
+        } else {
+          // ::error: [required.method.not.called]
+          s = new FileInputStream("test2.txt"); // false positive
+        }
+      }
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+      // ignore
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/FirstAssignmentInConstructor.java

@@ -0,0 +1,35 @@
+// Test: Field has no initializer and is first assigned in constructor in a try-catch block.
+// Expected: No warning in constructor, warning in open().
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class FirstAssignmentInConstructor {
+  private @Owning FileInputStream s;
+
+  public FirstAssignmentInConstructor() {
+    try {
+      s = new FileInputStream("test.txt"); // no warning
+    } catch (Exception e) {
+    }
+  }
+
+  // :: error: [missing.creates.mustcall.for]
+  public void open() {
+    try {
+      // :: error: [required.method.not.called]
+      s = new FileInputStream("test.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/FirstAssignmentInConstructorBlock.java

@@ -0,0 +1,74 @@
+// Test: Field has no initializer and is first assigned in constructor, but in a constructor block.
+// Expected: No warning in the first assignment in the constructor block, warning in any later
+// assignments in the constructor and in open().
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class FirstAssignmentInConstructorBlock {
+  private @Owning FileInputStream s;
+
+  static FileInputStream s2;
+  static FileInputStream s3;
+
+  public FirstAssignmentInConstructorBlock() {
+    s = s2;
+  }
+
+  public FirstAssignmentInConstructorBlock(boolean b) {
+    {
+      s = s2;
+    }
+  }
+
+  public FirstAssignmentInConstructorBlock(int i) {
+    {
+      s = s2;
+    }
+    // :: error: [required.method.not.called]
+    s = s2;
+  }
+
+  public FirstAssignmentInConstructorBlock(float f) {
+    s = s2;
+    {
+      // :: error: [required.method.not.called]
+      s = s2;
+    }
+  }
+
+  public FirstAssignmentInConstructorBlock(byte b) {
+    {
+      s = s3;
+    }
+    // :: error: [required.method.not.called]
+    s = s2;
+  }
+
+  public FirstAssignmentInConstructorBlock(char c) {
+    s = s2;
+    {
+      // :: error: [required.method.not.called]
+      s = s3;
+    }
+  }
+
+  // :: error: [missing.creates.mustcall.for]
+  public void open() {
+    try {
+      // :: error: [required.method.not.called]
+      s = new FileInputStream("test.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/InlineInitializerLeak.java

@@ -0,0 +1,33 @@
+// Test: Field has a non-null inline initializer and is reassigned in constructor and open().
+// Expected: Warning in constructor and in open().
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class InlineInitializerLeak {
+  private @Owning FileInputStream s = new FileInputStream("test.txt");
+
+  public InlineInitializerLeak() throws Exception {
+    // :: error: [required.method.not.called]
+    s = new FileInputStream("test.txt");
+  }
+
+  // :: error: [missing.creates.mustcall.for]
+  public void open() {
+    try {
+      // :: error: [required.method.not.called]
+      s = new FileInputStream("test.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.s", methods = "close")
+  public void close() {
+    try {
+      s.close();
+    } catch (Exception e) {
+    }
+  }
+}

checker/tests/resourceleak-firstinitconstructor/InstanceInitializerBlockLeak.java

@@ -0,0 +1,44 @@
+// Test: Field is assigned in an instance initializer block and reassigned later.
+// Expected: Warning in initializer block, constructor and open().
+
+import java.io.FileInputStream;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall({"close"})
+class InstanceInitializerBlockLeak {
+  private @Owning FileInputStream f;
+
+  {
+    try {
+      // :: error: [required.method.not.called]
+      f = new FileInputStream("file.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  public InstanceInitializerBlockLeak() {
+    try {
+      // :: error: [required.method.not.called]
+      f = new FileInputStream("file.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  // :: error: [missing.creates.mustcall.for]
+  public void open() {
+    try {
+      // :: error: [required.method.not.called]
+      f = new FileInputStream("file.txt");
+    } catch (Exception e) {
+    }
+  }
+
+  @EnsuresCalledMethods(value = "this.f", methods = "close")
+  public void close() {
+    try {
+      f.close();
+    } catch (Exception e) {
+    }
+  }
+}