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/src/main/java/org/checkerframework/checker/resourceleak/MustCallInference.java

@@ -8,6 +8,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Deque;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
@@ -24,6 +25,8 @@
 import javax.lang.model.type.TypeMirror;
 import org.checkerframework.checker.calledmethods.qual.EnsuresCalledMethods;
 import org.checkerframework.checker.mustcall.qual.InheritableMustCall;
+import org.checkerframework.checker.mustcall.qual.MustCallAlias;
+import org.checkerframework.checker.mustcall.qual.NotOwning;
 import org.checkerframework.checker.mustcall.qual.Owning;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.resourceleak.MustCallConsistencyAnalyzer.BlockWithObligations;
@@ -40,10 +43,12 @@
 import org.checkerframework.dataflow.cfg.block.SingleSuccessorBlock;
 import org.checkerframework.dataflow.cfg.node.ArrayCreationNode;
 import org.checkerframework.dataflow.cfg.node.AssignmentNode;
+import org.checkerframework.dataflow.cfg.node.FieldAccessNode;
 import org.checkerframework.dataflow.cfg.node.LocalVariableNode;
 import org.checkerframework.dataflow.cfg.node.MethodInvocationNode;
 import org.checkerframework.dataflow.cfg.node.Node;
 import org.checkerframework.dataflow.cfg.node.ObjectCreationNode;
+import org.checkerframework.dataflow.cfg.node.ReturnNode;
 import org.checkerframework.dataflow.expression.JavaExpression;
 import org.checkerframework.dataflow.expression.LocalVariable;
 import org.checkerframework.dataflow.util.NodeUtils;
@@ -58,7 +63,9 @@
 /**
  * This class implements the annotation inference algorithm for the Resource Leak Checker. It infers
  * annotations such as {@code @}{@link Owning} on owning fields and parameters, {@code @}{@link
- * EnsuresCalledMethods} on methods, and {@code @}{@link InheritableMustCall} on class declarations.
+ * NotOwning} on return types, {@code @}{@link EnsuresCalledMethods} on methods, {@code @}{@link
+ * MustCallAlias} on parameters and return types, and {@code @}{@link InheritableMustCall} on class
+ * declarations.
  *
  * <p>Each instance of this class corresponds to a single control flow graph (CFG), typically
  * representing a method.
@@ -110,6 +117,12 @@ public class MustCallInference {
   /** The {@link Owning} annotation. */
   protected final AnnotationMirror OWNING;
 
+  /** The {@link NotOwning} annotation. */
+  protected final AnnotationMirror NOTOWNING;
+
+  /** The {@link MustCallAlias} annotation. */
+  protected final AnnotationMirror MUSTCALLALIAS;
+
   /**
    * The control flow graph of the current method. There is a separate MustCallInference for each
    * method.
@@ -128,6 +141,13 @@ public class MustCallInference {
   /** The element referring to the enclosing class of the current method. */
   private final @Nullable TypeElement classElt;
 
+  /**
+   * This map is used to track must-alias relationships between return nodes and method parameters.
+   * The keys are the obligation of return nodes, and the values are the index of current method
+   * formal parameter (1-based) that is aliased with the return node.
+   */
+  private final Map<Obligation, Integer> returnNodeToParameterIndexMap = new HashMap<>();
+
   /**
    * Creates a MustCallInference instance.
    *
@@ -143,6 +163,10 @@ public class MustCallInference {
     this.mcca = mcca;
     this.cfg = cfg;
     OWNING = AnnotationBuilder.fromClass(this.resourceLeakAtf.getElementUtils(), Owning.class);
+    NOTOWNING =
+        AnnotationBuilder.fromClass(this.resourceLeakAtf.getElementUtils(), NotOwning.class);
+    MUSTCALLALIAS =
+        AnnotationBuilder.fromClass(this.resourceLeakAtf.getElementUtils(), MustCallAlias.class);
     methodTree = ((UnderlyingAST.CFGMethod) cfg.getUnderlyingAST()).getMethod();
     methodElt = TreeUtils.elementFromDeclaration(methodTree);
     classTree = TreePathUtil.enclosingClass(resourceLeakAtf.getPath(methodTree));
@@ -216,7 +240,9 @@ private void runInference() {
           mcca.updateObligationsWithInvocationResult(obligations, node);
           computeOwningFromInvocation(obligations, node);
         } else if (node instanceof AssignmentNode) {
-          analyzeOwnershipTransferAtAssignment(obligations, (AssignmentNode) node);
+          analyzeAssignmentNode(obligations, (AssignmentNode) node);
+        } else if (node instanceof ReturnNode) {
+          analyzeReturnNode(obligations, (ReturnNode) node);
         }
       }
 
@@ -226,10 +252,46 @@ private void runInference() {
     addMemberAndClassAnnotations();
   }
 
+  /**
+   * Analyzes a return statement and performs two computations:
+   *
+   * <ul>
+   *   <li>If the returned expression is a field with non-empty must-call obligations, adds a {@link
+   *       NotOwning} annotation to the return type of the current method. Note the implication: if
+   *       a method returns a field of this class at <i>any</i> return site, the return type is
+   *       inferred to be non-owning.
+   *   <li>Compute the index of the parameter that is an alias of the return node and add it the
+   *       {@link #returnNodeToParameterIndexMap} map. This map will be used later to infer the
+   *       {@link MustCallAlias} annotation for method parameters.
+   * </ul>
+   *
+   * @param obligations set of obligations associated with the current block
+   * @param node the return node
+   */
+  private void analyzeReturnNode(Set<Obligation> obligations, ReturnNode node) {
+    Node returnNode = node.getResult();
+    returnNode = mcca.removeCastsAndGetTmpVarIfPresent(returnNode);
+    if (resourceLeakAtf.hasEmptyMustCallValue(returnNode.getTree())) {
+      return;
+    }
+
+    if (returnNode instanceof FieldAccessNode) {
+      addNotOwning();
+    } else if (returnNode instanceof LocalVariableNode) {
+      Obligation returnNodeObligation =
+          MustCallConsistencyAnalyzer.getObligationForVar(
+              obligations, (LocalVariableNode) returnNode);
+      if (returnNodeObligation != null) {
+        returnNodeToParameterIndexMap.put(
+            returnNodeObligation, getIndexOfParam(returnNodeObligation));
+      }
+    }
+  }
+
   /**
    * Adds inferred {@literal @Owning} annotations to fields, {@literal @EnsuresCalledMethods}
-   * annotations to the current method, and {@literal @InheritableMustCall} annotation to the
-   * enclosing class.
+   * annotations to the current method, {@literal @MustCallAlias} annotation to the parameter, and
+   * {@literal @InheritableMustCall} annotation to the enclosing class.
    */
   private void addMemberAndClassAnnotations() {
     WholeProgramInference wpi = resourceLeakAtf.getWholeProgramInference();
@@ -241,6 +303,17 @@ private void addMemberAndClassAnnotations() {
       addEnsuresCalledMethods();
     }
 
+    // If all return statements alias the same parameter index, then add the @MustCallAlias
+    // annotation to that parameter and the return type.
+    if (!returnNodeToParameterIndexMap.isEmpty()) {
+      if (returnNodeToParameterIndexMap.values().stream().distinct().count() == 1) {
+        int indexOfParam = returnNodeToParameterIndexMap.values().iterator().next();
+        if (indexOfParam > 0) {
+          addMustCallAlias(indexOfParam);
+        }
+      }
+    }
+
     addOrUpdateClassMustCall();
   }
 
@@ -323,9 +396,13 @@ private void inferOwningField(Node node, MethodInvocationNode invocation) {
   }
 
   /**
-   * Analyzes an assignment statement and performs three computations:
+   * Analyzes an assignment statement and performs the following computations:
    *
    * <ul>
+   *   <li>If the current method under analysis is a constructor, the left-hand side of the
+   *       assignment is the only owning field of the enclosing class, and the rhs is an alias of a
+   *       formal parameter, it adds an {@code @MustCallAlias} annotation to the formal parameter
+   *       and the result type of the constructor.
    *   <li>If the left-hand side of the assignment is an owning field, and the rhs is an alias of a
    *       formal parameter, it adds an {@code @Owning} annotation to the formal parameter.
    *   <li>If the left-hand side of the assignment is a resource variable, and the right-hand side
@@ -338,13 +415,11 @@ private void inferOwningField(Node node, MethodInvocationNode invocation) {
    * @param obligations the set of obligations to update
    * @param assignmentNode the assignment statement
    */
-  private void analyzeOwnershipTransferAtAssignment(
-      Set<Obligation> obligations, AssignmentNode assignmentNode) {
+  private void analyzeAssignmentNode(Set<Obligation> obligations, AssignmentNode assignmentNode) {
     Node lhs = assignmentNode.getTarget();
     Element lhsElement = TreeUtils.elementFromTree(lhs.getTree());
     // Use the temporary variable for the rhs if it exists.
-    Node rhs = NodeUtils.removeCasts(assignmentNode.getExpression());
-    rhs = mcca.getTempVarOrNode(rhs);
+    Node rhs = mcca.removeCastsAndGetTmpVarIfPresent(assignmentNode.getExpression());
 
     if (!(rhs instanceof LocalVariableNode)) {
       return;
@@ -368,41 +443,71 @@ private void analyzeOwnershipTransferAtAssignment(
       if (!TreeUtils.isConstructor(methodTree)) {
         disposedFields.remove((VariableElement) lhsElement);
       }
-      addOwningToParamsIfDisposedAtAssignment(obligations, rhsObligation, rhs);
+
+      int paramIndex = getIndexOfParam(rhsObligation);
+      if (paramIndex == -1) {
+        // We are only tracking formal parameter aliases. If the rhsObligation is not an alias of
+        // any of the formal parameters, it won't be present in the obligations set. Thus, skipping
+        // the rest of this method is fine.
+        return;
+      }
+
+      if (TreeUtils.isConstructor(methodTree) && updateOwningFields().size() == 1) {
+        addMustCallAlias(paramIndex);
+        mcca.removeObligationsContainingVar(obligations, (LocalVariableNode) rhs);
+      } else {
+        addOwningToParam(paramIndex);
+        mcca.removeObligationsContainingVar(obligations, (LocalVariableNode) rhs);
+      }
+
     } else if (lhsElement.getKind() == ElementKind.RESOURCE_VARIABLE && mcca.isMustCallClose(rhs)) {
-      addOwningToParamsIfDisposedAtAssignment(obligations, rhsObligation, rhs);
+      int paramIndex = getIndexOfParam(rhsObligation);
+      if (paramIndex > 0) {
+        addOwningToParam(paramIndex);
+      }
     } else if (lhs instanceof LocalVariableNode) {
       LocalVariableNode lhsVar = (LocalVariableNode) lhs;
       mcca.updateObligationsForPseudoAssignment(obligations, assignmentNode, lhsVar, rhs);
     }
   }
 
   /**
-   * If a must-call obligation of some alias of method parameter p is satisfied during the
-   * assignment, add an @Owning annotation to p, and remove the rhs node from the obligations set,
-   * since it no longer needs to be tracked.
+   * Return the (1-based) index of the method parameter that is an alias of the given {@code
+   * obligation}, if one exists; otherwise, return -1.
    *
-   * @param obligations the set of obligations to update
-   * @param rhsObligation the obligation associated with the right-hand side of the assignment
-   * @param rhs the right-hand side of the assignment
+   * @param obligation the obligation
+   * @return the index of the current method parameter that is must-aliased to the given obligation,
+   *     if one exists; otherwise, return -1.
    */
-  private void addOwningToParamsIfDisposedAtAssignment(
-      Set<Obligation> obligations, Obligation rhsObligation, Node rhs) {
-    Set<ResourceAlias> rhsAliases = rhsObligation.resourceAliases;
-    if (rhsAliases.isEmpty()) {
-      return;
-    }
+  private int getIndexOfParam(Obligation obligation) {
+    Set<ResourceAlias> resourceAliases = obligation.resourceAliases;
     List<VariableElement> paramElts =
         CollectionsPlume.mapList(TreeUtils::elementFromDeclaration, methodTree.getParameters());
-    for (ResourceAlias rhsAlias : rhsAliases) {
-      Element rhsElt = rhsAlias.element;
-      int i = paramElts.indexOf(rhsElt);
-      if (i != -1) {
-        addOwningToParam(i + 1);
-        mcca.removeObligationsContainingVar(obligations, (LocalVariableNode) rhs);
-        break;
+    for (ResourceAlias resourceAlias : resourceAliases) {
+      int paramIndex = paramElts.indexOf(resourceAlias.element);
+      if (paramIndex != -1) {
+        return paramIndex + 1;
       }
     }
+
+    return -1;
+  }
+
+  /** Adds a {@link NotOwning} annotation to the return type of the current method. */
+  private void addNotOwning() {
+    WholeProgramInference wpi = resourceLeakAtf.getWholeProgramInference();
+    wpi.addMethodDeclarationAnnotation(methodElt, NOTOWNING);
+  }
+
+  /**
+   * Adds a {@link MustCallAlias} annotation to the formal parameter at the given index.
+   *
+   * @param index the index of a formal parameter of the current method (1-based)
+   */
+  private void addMustCallAlias(int index) {
+    WholeProgramInference wpi = resourceLeakAtf.getWholeProgramInference();
+    wpi.addMethodDeclarationAnnotation(methodElt, MUSTCALLALIAS);
+    wpi.addDeclarationAnnotationToFormalParameter(methodElt, index, MUSTCALLALIAS);
   }
 
   /**
@@ -567,7 +672,7 @@ private void computeOwningForArgsOrReceiverOfCall(
     }
 
     for (Node argument : mcca.getArgumentsOfInvocation(invocation)) {
-      Node arg = NodeUtils.removeCasts(argument);
+      Node arg = mcca.removeCastsAndGetTmpVarIfPresent(argument);
       // In the CFG, explicit passing of multiple arguments in the varargs position is represented
       // via an ArrayCreationNode. In this case, it checks the called methods set of each argument
       // passed in this position.
@@ -651,14 +756,16 @@ private Set<ResourceAlias> getResourceAliasOfNode(Set<Obligation> obligations, N
   }
 
   /**
-   * Infers @Owning annotations for formal parameters of the enclosing method or fields of the
-   * enclosing class, as follows:
+   * Infers @Owning or @MustCallAlias annotations for formal parameters of the enclosing method
+   * and @Owning annotation for fields of the enclosing class, as follows:
    *
    * <ul>
    *   <li>If a formal parameter is passed as an owning parameter, add an @Owning annotation to that
    *       formal parameter (see {@link #inferOwningParamsViaOwnershipTransfer}).
    *   <li>It calls {@link #computeOwningForArgsOrReceiverOfCall} to compute @Owning annotations for
    *       the receiver or arguments of a call by analyzing the called-methods set after the call.
+   *   <li>It calls {@link #computeMustCallAliasFromThisOrSuperCall} to compute @MustCallAlias
+   *       annotation for formal parameters and the result of the constructor.
    * </ul>
    *
    * @param obligations the set of obligations to search in
@@ -671,11 +778,46 @@ private void computeOwningFromInvocation(Set<Obligation> obligations, Node invoc
       // @EnsuresCalledMethods annotations on constructors as we have not observed them in practice.
       inferOwningParamsViaOwnershipTransfer(obligations, invocation);
     } else if (invocation instanceof MethodInvocationNode) {
+      computeMustCallAliasFromThisOrSuperCall(obligations, (MethodInvocationNode) invocation);
       inferOwningParamsViaOwnershipTransfer(obligations, invocation);
       computeOwningForArgsOrReceiverOfCall(obligations, (MethodInvocationNode) invocation);
     }
   }
 
+  /**
+   * Adds the @MustCallAlias annotation to a method parameter when it is passed in a @MustCallAlias
+   * position during a constructor call using {@literal this} or {@literal super}.
+   *
+   * @param obligations the set of obligations associated with the current block
+   * @param node a method invocation node
+   */
+  private void computeMustCallAliasFromThisOrSuperCall(
+      Set<Obligation> obligations, MethodInvocationNode node) {
+    if (!TreeUtils.isSuperConstructorCall(node.getTree())
+        && !TreeUtils.isThisConstructorCall(node.getTree())) {
+      return;
+    }
+    List<? extends VariableElement> calleeParams = mcca.getParametersOfInvocation(node);
+    List<Node> arguments = mcca.getArgumentsOfInvocation(node);
+    for (int i = 0; i < arguments.size(); i++) {
+      if (!resourceLeakAtf.hasMustCallAlias(calleeParams.get(i))) {
+        continue;
+      }
+
+      Node arg = mcca.removeCastsAndGetTmpVarIfPresent(arguments.get(i));
+      Obligation argObligation =
+          MustCallConsistencyAnalyzer.getObligationForVar(obligations, (LocalVariableNode) arg);
+      if (argObligation == null) {
+        return;
+      }
+      int index = getIndexOfParam(argObligation);
+      if (index != -1) {
+        addMustCallAlias(index);
+        break;
+      }
+    }
+  }
+
   /**
    * Returns the called methods annotation for the given Java expression after the invocation node.
    *