Second Phase of RLC inference

checker/src/main/java/org/checkerframework/checker/resourceleak/MustCallConsistencyAnalyzer.java

@@ -1815,7 +1815,7 @@ private List<Node> getMustCallAliasArgumentNodes(Node callNode) {
    * @param node a node
    * @return either a tempvar for node's content sans typecasts, or node
    */
-  private Node removeCastsAndGetTmpVarIfPresent(Node node) {
+  /*package-private*/ Node removeCastsAndGetTmpVarIfPresent(Node node) {
     // TODO: Create temp vars for TypeCastNodes as well, so there is no need to explicitly
     // remove casts here.
     node = NodeUtils.removeCasts(node);

checker/tests/ainfer-resourceleak/non-annotated/AddNotOwning.java

@@ -0,0 +1,92 @@
+// This test ensures that the @NotOwning annotation is inferred for the return type of a method if
+// it returns a field.
+
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+class AddNotOwning {
+
+  @InheritableMustCall("a")
+  static class Foo {
+    void a() {}
+  }
+
+  static class NonEmptyMustCallFinalField {
+    final Foo f; // expect owning annotation for this field
+
+    NonEmptyMustCallFinalField() {
+      // :: warning: (required.method.not.called)
+      f = new Foo();
+    }
+
+    Foo getField() {
+      return f;
+    }
+
+    Foo getFieldOnSomePath() {
+      if (true) {
+        return null;
+      } else {
+        return f;
+      }
+    }
+
+    void testNotOwningOnFinal() {
+      // :: warning: (required.method.not.called)
+      Foo f = getField();
+    }
+
+    void testNotOwningOnGetFieldOnSomePath() {
+      // :: warning: (required.method.not.called)
+      Foo f = getFieldOnSomePath();
+    }
+
+    @EnsuresCalledMethods(
+        value = {"this.f"},
+        methods = {"a"})
+    void dispose() {
+      f.a();
+    }
+  }
+
+  @InheritableMustCall("dispose")
+  static class NonEmptyMustCallNonFinalField {
+    Foo f; // expect owning annotation for this field
+
+    @SuppressWarnings("missing.creates.mustcall.for")
+    void initialyzeFoo() {
+      f.a();
+      // :: warning: (required.method.not.called)
+      f = new Foo();
+    }
+
+    Foo getField() {
+      return f;
+    }
+
+    Foo getFieldOnSomePath() {
+      if (true) {
+        return null;
+      } else {
+        return f;
+      }
+    }
+
+    void testNotOwningOnNonFinal() {
+      // :: warning: (required.method.not.called)
+      Foo f = getField();
+    }
+
+    void testNotOwningOnGetFieldOnSomePath() {
+      // :: warning: (required.method.not.called)
+      Foo f = getFieldOnSomePath();
+    }
+
+    @EnsuresCalledMethods(
+        value = {"this.f"},
+        methods = {"a"})
+    void dispose() {
+      f.a();
+    }
+  }
+}

checker/tests/ainfer-resourceleak/non-annotated/ClassWithTwoOwningFieldsTest.java

@@ -0,0 +1,40 @@
+// This test ensures that the @MustCallAlias annotation is not inferred when the enclosing class has
+// more than one owning field.
+
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+class ClassWithTwoOwningFieldsTest {
+  @InheritableMustCall("a")
+  static class Foo {
+    void a() {}
+  }
+
+  @InheritableMustCall("close")
+  private class ClassWithTwoOwningFields {
+    // :: warning: (required.method.not.called)
+    final @Owning Foo foo1;
+    // :: warning: (required.method.not.called)
+    final @Owning Foo foo2;
+
+    public ClassWithTwoOwningFields(Foo f1, Foo f2) {
+      foo1 = f1;
+      foo2 = f2;
+    }
+
+    void close() {
+      foo1.a();
+      foo2.a();
+    }
+  }
+
+  void testTwoOwning() {
+    // :: warning: (required.method.not.called)
+    Foo f1 = new Foo();
+    // :: warning: (required.method.not.called)
+    Foo f2 = new Foo();
+
+    ClassWithTwoOwningFields ff = new ClassWithTwoOwningFields(f1, f2);
+    ff.close();
+  }
+}

checker/tests/ainfer-resourceleak/non-annotated/MustCallAliasOnReceiver.java

@@ -0,0 +1,40 @@
+// @skip-test until we have support for adding annotation on the receiver parameter.
+
+import java.io.*;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+@InheritableMustCall("close")
+public class MustCallAliasOnReceiver {
+
+  final @Owning InputStream is;
+
+  @MustCallAlias MustCallAliasOnReceiver(@MustCallAlias InputStream p, boolean b) {
+    this.is = p;
+  }
+
+  MustCallAliasOnReceiver returnReceiver(MustCallAliasOnReceiver this) {
+    return this;
+  }
+
+  // :: warning: (required.method.not.called)
+  void testReceiverMCAAnnotation(@Owning InputStream inputStream) throws IOException {
+    MustCallAliasOnReceiver mcar = new MustCallAliasOnReceiver(is, false);
+    mcar.returnReceiver().close();
+  }
+
+  @EnsuresCalledMethods(value = "this.is", methods = "close")
+  public void close() throws IOException {
+    this.is.close();
+  }
+
+  public static MustCallAliasOnReceiver mcaneFactory(InputStream is) {
+    return new MustCallAliasOnReceiver(is, false);
+  }
+
+  // :: warning: (required.method.not.called)
+  public static void testUse(@Owning InputStream inputStream) throws Exception {
+    MustCallAliasOnReceiver mcane = mcaneFactory(inputStream);
+    mcane.close();
+  }
+}

checker/tests/ainfer-resourceleak/non-annotated/MustCallAliasOnRegularExits.java

@@ -0,0 +1,52 @@
+// This test ensures that the all-paths condition for inferring the @MustCallAlias annotation is
+// restricted to the examination of 'Regular' paths.
+
+import java.io.IOException;
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+class MustCallAliasOnRegularExits {
+
+  @InheritableMustCall("a")
+  static class Foo {
+    void a() {}
+
+    int b() throws IOException {
+      return 0;
+    }
+  }
+
+  private class MCAConstructor extends Foo {
+
+    protected final @Owning Foo f;
+    protected long s = 0L;
+
+    // The Must Call Checker for assigning @MustCallAlias parameters to @Owning fields reports a
+    // false positive.
+    @SuppressWarnings("assignment")
+    protected MCAConstructor(Foo foo) throws IOException {
+      if (foo == null) {
+        this.s = foo.b();
+      }
+      this.f = foo;
+    }
+
+    @EnsuresCalledMethods(
+        value = {"this.f"},
+        methods = {"a"})
+    public void a() {
+      f.a();
+    }
+  }
+
+  void testMCAOnMCAConstructor() {
+    Foo f = new Foo();
+    try {
+      // :: warning: (required.method.not.called)
+      MCAConstructor mcaf = new MCAConstructor(f);
+    } catch (IOException e) {
+    } finally {
+      f.a();
+    }
+  }
+}

checker/tests/ainfer-resourceleak/non-annotated/MustCallAliasParams.java

@@ -0,0 +1,159 @@
+// This test examines all scenarios for inferring the @MustCallAlias annotation.
+
+import org.checkerframework.checker.calledmethods.qual.*;
+import org.checkerframework.checker.mustcall.qual.*;
+
+class MustCallAliasParams {
+
+  @InheritableMustCall("a")
+  static class Foo {
+    void a() {}
+  }
+
+  @InheritableMustCall("a")
+  private class MCAConstructor {
+
+    final @Owning Foo f;
+
+    // The Must Call Checker for assigning @MustCallAlias parameters to @Owning fields reports a
+    // false positive.
+    @SuppressWarnings("assignment")
+    MCAConstructor(Foo foo) {
+      f = foo;
+    }
+
+    @EnsuresCalledMethods(
+        value = {"this.f"},
+        methods = {"a"})
+    public void a() {
+      f.a();
+    }
+  }
+
+  void testMCAConstructor() {
+    // :: warning: (required.method.not.called)
+    Foo f = new Foo();
+    MCAConstructor mcac = new MCAConstructor(f);
+    mcac.a();
+  }
+
+  @InheritableMustCall("a")
+  private class MCASuperClass {
+    int i;
+    final @Owning Foo f;
+
+    // The Must Call Checker for assigning @MustCallAlias parameters to @Owning fields reports a
+    // false positive.
+    @SuppressWarnings("assignment")
+    @MustCallAlias MCASuperClass(@MustCallAlias Foo foo, int i) {
+      f = foo;
+      i = i;
+    }
+
+    @EnsuresCalledMethods(
+        value = {"this.f"},
+        methods = {"a"})
+    public void a() {
+      f.a();
+    }
+  }
+
+  private class MCASuperCall extends MCASuperClass {
+    MCASuperCall(Foo foo) {
+      super(foo, 1);
+    }
+  }
+
+  void mCASuperCallTest() {
+    // :: warning: (required.method.not.called)
+    Foo f = new Foo();
+    MCASuperCall mcaSuperCall = new MCASuperCall(f);
+    mcaSuperCall.a();
+  }
+
+  private class MCAThisCall extends MCASuperClass {
+    @MustCallAlias MCAThisCall(@MustCallAlias Foo foo) {
+      super(foo, 1);
+    }
+
+    MCAThisCall(Foo foo, boolean b) {
+      this(foo);
+    }
+  }
+
+  void mCAThisCallTest() {
+    // :: warning: (required.method.not.called)
+    Foo f = new Foo();
+    MCAThisCall mcaThisCall = new MCAThisCall(f, true);
+    mcaThisCall.a();
+  }
+
+  private class MCAMethod {
+    Foo returnFoo(Foo foo) {
+      return foo;
+    }
+
+    void returnFooTest() {
+      // :: warning: (required.method.not.called)
+      Foo f = new Foo();
+      Foo foo = returnFoo(f);
+      foo.a();
+    }
+
+    Foo returnAliasFoo(Foo foo) {
+      Foo f = foo;
+      return f;
+    }
+
+    MCASuperClass returnAliasFoo2(Foo foo, int i) {
+      MCASuperClass f = new MCASuperClass(foo, i);
+      return f;
+    }
+
+    void testReturnAliasFoo2() {
+      // :: warning: (required.method.not.called)
+      Foo foo = new Foo();
+      MCASuperClass f = returnAliasFoo2(foo, 0);
+      f.a();
+    }
+
+    void returnAliasFooTest() {
+      // :: warning: (required.method.not.called)
+      Foo f = new Foo();
+      Foo foo = returnAliasFoo(f);
+      foo.a();
+    }
+
+    Foo returnFooAllPaths(Foo foo) {
+      if (true) {
+        Foo f = foo;
+        return f;
+      } else {
+        return foo;
+      }
+    }
+
+    void returnFooAllPathsTest() {
+      // :: warning: (required.method.not.called)
+      Foo f = new Foo();
+      Foo foo = returnFooAllPaths(f);
+      foo.a();
+    }
+
+    Foo returnFooSomePath(Foo foo) {
+      if (true) {
+        Foo f = new Foo();
+        return f;
+      } else {
+        return foo;
+      }
+    }
+
+    void returnFooSomePathTest() {
+      Foo f = new Foo();
+      Foo foo = returnFooSomePath(f);
+      f.a();
+      foo.a();
+    }
+  }
+}