Rust: Add {BreakExpr,ContinueExpr}.getTarget()

Author: hvitved

rust/ql/.generated.list

@@ -145,44 +145,26 @@ class BlockExprTree extends StandardPostOrderTree, BlockExpr {
     result = super.getStmtList().getTailExpr()
   }
 
-  override predicate propagatesAbnormal(AstNode child) { none() }
-
-  /** Holds if this block captures the break completion `c`. */
-  private predicate capturesBreakCompletion(LoopJumpCompletion c) {
-    c.isBreak() and
-    c.getLabelName() = this.getLabel().getLifetime().getText()
-  }
-
-  override predicate succ(AstNode pred, AstNode succ, Completion c) {
-    super.succ(pred, succ, c)
-    or
-    // Edge for exiting the block with a break expressions
-    last(this.getChildNode(_), pred, c) and
-    this.capturesBreakCompletion(c) and
-    succ = this
-  }
-
-  override predicate last(AstNode last, Completion c) {
-    super.last(last, c)
-    or
-    // Any abnormal completions that this block does not capture should propagate
-    last(this.getChildNode(_), last, c) and
-    not completionIsNormal(c) and
-    not this.capturesBreakCompletion(c)
-  }
+  override predicate propagatesAbnormal(AstNode child) { child = this.getChildNode(_) }
 }
 
-class BreakExprTree extends PostOrderTree instanceof BreakExpr {
-  override predicate propagatesAbnormal(AstNode child) { child = super.getExpr() }
+class BreakExprTree extends PostOrderTree, BreakExpr {
+  override predicate propagatesAbnormal(AstNode child) { child = this.getExpr() }
 
   override predicate first(AstNode node) {
-    first(super.getExpr(), node)
+    first(this.getExpr(), node)
     or
-    not super.hasExpr() and node = this
+    not this.hasExpr() and node = this
   }
 
+  override predicate last(AstNode last, Completion c) { none() }
+
   override predicate succ(AstNode pred, AstNode succ, Completion c) {
     last(super.getExpr(), pred, c) and succ = this
+    or
+    pred = this and
+    c.isValidFor(pred) and
+    succ = this.getTarget()
   }
 }
 
@@ -200,7 +182,18 @@ class CastExprTree extends StandardPostOrderTree instanceof CastExpr {
 
 class ClosureExprTree extends LeafTree instanceof ClosureExpr { }
 
-class ContinueExprTree extends LeafTree instanceof ContinueExpr { }
+class ContinueExprTree extends LeafTree, ContinueExpr {
+  override predicate last(AstNode last, Completion c) { none() }
+
+  override predicate succ(AstNode pred, AstNode succ, Completion c) {
+    exists(Expr target |
+      pred = this and
+      c.isValidFor(pred) and
+      target = this.getTarget() and
+      first(target.(LoopingExprTree).getLoopContinue(), succ)
+    )
+  }
+}
 
 class ExprStmtTree extends StandardPreOrderTree instanceof ExprStmt {
   override AstNode getChildNode(int i) { i = 0 and result = super.getExpr() }
@@ -310,57 +303,27 @@ class LetStmtTree extends PreOrderTree instanceof LetStmt {
 class LiteralExprTree extends LeafTree instanceof LiteralExpr { }
 
 abstract class LoopingExprTree extends PostOrderTree {
-  override predicate propagatesAbnormal(AstNode child) { none() }
+  override predicate propagatesAbnormal(AstNode child) { child = this.getLoopBody() }
 
   abstract BlockExpr getLoopBody();
 
-  abstract Label getLabel();
-
   /**
    * Gets the node to execute when continuing the loop; either after
    * executing the last node in the body or after an explicit `continue`.
    */
   abstract AstNode getLoopContinue();
 
-  /** Holds if this loop captures the `c` completion. */
-  private predicate capturesLoopJumpCompletion(LoopJumpCompletion c) {
-    not c.hasLabel()
-    or
-    c.getLabelName() = this.getLabel().getLifetime().getText()
-  }
-
   override predicate succ(AstNode pred, AstNode succ, Completion c) {
-    // Edge for exiting the loop with a break expressions
-    last(this.getLoopBody(), pred, c) and
-    c.(LoopJumpCompletion).isBreak() and
-    this.capturesLoopJumpCompletion(c) and
-    succ = this
-    or
     // Edge back to the start for final expression and continue expressions
     last(this.getLoopBody(), pred, c) and
-    (
-      completionIsNormal(c)
-      or
-      c.(LoopJumpCompletion).isContinue() and this.capturesLoopJumpCompletion(c)
-    ) and
+    completionIsNormal(c) and
     first(this.getLoopContinue(), succ)
   }
-
-  override predicate last(AstNode last, Completion c) {
-    super.last(last, c)
-    or
-    // Any abnormal completions that this loop does not capture should propagate
-    last(this.getLoopBody(), last, c) and
-    not completionIsNormal(c) and
-    not this.capturesLoopJumpCompletion(c)
-  }
 }
 
 class LoopExprTree extends LoopingExprTree instanceof LoopExpr {
   override BlockExpr getLoopBody() { result = LoopExpr.super.getLoopBody() }
 
-  override Label getLabel() { result = LoopExpr.super.getLabel() }
-
   override AstNode getLoopContinue() { result = this.getLoopBody() }
 
   override predicate first(AstNode node) { first(this.getLoopBody(), node) }
@@ -369,11 +332,13 @@ class LoopExprTree extends LoopingExprTree instanceof LoopExpr {
 class WhileExprTree extends LoopingExprTree instanceof WhileExpr {
   override BlockExpr getLoopBody() { result = WhileExpr.super.getLoopBody() }
 
-  override Label getLabel() { result = WhileExpr.super.getLabel() }
-
   override AstNode getLoopContinue() { result = super.getCondition() }
 
-  override predicate propagatesAbnormal(AstNode child) { child = super.getCondition() }
+  override predicate propagatesAbnormal(AstNode child) {
+    super.propagatesAbnormal(child)
+    or
+    child = super.getCondition()
+  }
 
   override predicate first(AstNode node) { first(super.getCondition(), node) }
 
@@ -399,11 +364,13 @@ class WhileExprTree extends LoopingExprTree instanceof WhileExpr {
 class ForExprTree extends LoopingExprTree instanceof ForExpr {
   override BlockExpr getLoopBody() { result = ForExpr.super.getLoopBody() }
 
-  override Label getLabel() { result = ForExpr.super.getLabel() }
-
   override AstNode getLoopContinue() { result = super.getPat() }
 
-  override predicate propagatesAbnormal(AstNode child) { child = super.getIterable() }
+  override predicate propagatesAbnormal(AstNode child) {
+    super.propagatesAbnormal(child)
+    or
+    child = super.getIterable()
+  }
 
   override predicate first(AstNode node) { first(super.getIterable(), node) }
 

rust/ql/.gitattributes

@@ -1,4 +1,3 @@
-// generated by codegen, remove this comment if you wish to edit this file
 /**
  * This module provides a hand-modifiable wrapper around the generated class `BreakExpr`.
  *
@@ -12,6 +11,58 @@ private import codeql.rust.elements.internal.generated.BreakExpr
  * be referenced directly.
  */
 module Impl {
+  private import rust
+  private import codeql.rust.elements.internal.generated.ParentChild
+
+  /** Holds if `e` is a loop labelled `label`. */
+  pragma[nomagic]
+  predicate isLabelledLoop(Expr e, string label) {
+    e =
+      any(LoopExpr le |
+        label = le.getLabel().getLifetime().getText()
+        or
+        label = ""
+      )
+    or
+    e =
+      any(ForExpr fe |
+        label = fe.getLabel().getLifetime().getText()
+        or
+        label = ""
+      )
+    or
+    e =
+      any(WhileExpr we |
+        label = we.getLabel().getLifetime().getText()
+        or
+        label = ""
+      )
+  }
+
+  pragma[nomagic]
+  private predicate isLabelled(Expr e, string label) {
+    isLabelledLoop(e, label)
+    or
+    label = e.(BlockExpr).getLabel().getLifetime().getText()
+  }
+
+  pragma[nomagic]
+  private AstNode getABreakAncestor(BreakExpr be, string label) {
+    (
+      label = be.getLifetime().getText()
+      or
+      not be.hasLifetime() and
+      label = ""
+    ) and
+    exists(AstNode n0 | result = getImmediateParent(n0) |
+      n0 = be
+      or
+      n0 = getABreakAncestor(be, label) and
+      not isLabelled(n0, label)
+    )
+  }
+
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
   /**
    * A break expression. For example:
    * ```rust
@@ -37,5 +88,19 @@ module Impl {
    * };
    * ```
    */
-  class BreakExpr extends Generated::BreakExpr { }
+  class BreakExpr extends Generated::BreakExpr {
+    /**
+     * Gets the target of this `break` expression.
+     *
+     * The target is either a `LoopExpr`, a `ForExpr`, a `WhileExpr`, or a
+     * `BlockExpr`.
+     */
+    pragma[nomagic]
+    Expr getTarget() {
+      exists(string label |
+        result = getABreakAncestor(this, label) and
+        isLabelled(result, label)
+      )
+    }
+  }
 }

rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll

@@ -1,4 +1,3 @@
-// generated by codegen, remove this comment if you wish to edit this file
 /**
  * This module provides a hand-modifiable wrapper around the generated class `ContinueExpr`.
  *
@@ -12,6 +11,26 @@ private import codeql.rust.elements.internal.generated.ContinueExpr
  * be referenced directly.
  */
 module Impl {
+  private import codeql.rust.elements.internal.BreakExprImpl::Impl as BreakExprImpl
+  private import codeql.rust.elements.internal.generated.ParentChild
+
+  pragma[nomagic]
+  private AstNode getAContinueAncestor(ContinueExpr ce, string label) {
+    (
+      label = ce.getLifetime().getText()
+      or
+      not ce.hasLifetime() and
+      label = ""
+    ) and
+    exists(AstNode n0 | result = getImmediateParent(n0) |
+      n0 = ce
+      or
+      n0 = getAContinueAncestor(ce, label) and
+      not BreakExprImpl::isLabelledLoop(n0, label)
+    )
+  }
+
+  // the following QLdoc is generated: if you need to edit it, do it in the schema file
   /**
    * A continue expression. For example:
    * ```rust
@@ -29,5 +48,18 @@ module Impl {
    * }
    * ```
    */
-  class ContinueExpr extends Generated::ContinueExpr { }
+  class ContinueExpr extends Generated::ContinueExpr {
+    /**
+     * Gets the target of this `continue` expression.
+     *
+     * The target is either a `LoopExpr`, a `ForExpr`, or a `WhileExpr`.
+     */
+    pragma[nomagic]
+    Expr getTarget() {
+      exists(string label |
+        result = getAContinueAncestor(this, label) and
+        BreakExprImpl::isLabelledLoop(result, label)
+      )
+    }
+  }
 }

rust/ql/lib/codeql/rust/elements/internal/BreakExprImpl.qll

@@ -1,3 +1,4 @@
+edges
 | test.rs:1:1:4:1 | enter test_call | test.rs:2:5:2:41 | ExprStmt |  |
 | test.rs:1:1:4:1 | exit test_call (normal) | test.rs:1:1:4:1 | exit test_call |  |
 | test.rs:1:24:4:1 | BlockExpr | test.rs:1:1:4:1 | exit test_call (normal) |  |
@@ -545,3 +546,25 @@
 | test.rs:299:13:299:27 | ExprStmt | test.rs:299:26:299:26 | 1 |  |
 | test.rs:299:26:299:26 | 1 | test.rs:299:13:299:26 | BreakExpr |  |
 | test.rs:301:9:301:9 | x | test.rs:296:18:302:5 | BlockExpr |  |
+breakTarget
+| test.rs:16:17:16:21 | BreakExpr | test.rs:10:9:22:9 | LoopExpr |
+| test.rs:30:21:30:25 | BreakExpr | test.rs:28:13:35:13 | LoopExpr |
+| test.rs:32:21:32:32 | BreakExpr | test.rs:27:9:36:9 | LoopExpr |
+| test.rs:34:17:34:28 | BreakExpr | test.rs:28:13:35:13 | LoopExpr |
+| test.rs:73:17:73:21 | BreakExpr | test.rs:70:9:76:9 | WhileExpr |
+| test.rs:83:17:83:21 | BreakExpr | test.rs:81:9:85:9 | WhileExpr |
+| test.rs:91:17:91:21 | BreakExpr | test.rs:89:9:94:9 | ForExpr |
+| test.rs:170:17:170:28 | BreakExpr | test.rs:168:13:173:9 | LoopExpr |
+| test.rs:183:17:183:35 | BreakExpr | test.rs:181:13:186:9 | LoopExpr |
+| test.rs:195:13:195:30 | BreakExpr | test.rs:194:13:196:9 | BlockExpr |
+| test.rs:284:13:284:26 | BreakExpr | test.rs:281:18:292:5 | BlockExpr |
+| test.rs:288:13:288:26 | BreakExpr | test.rs:281:18:292:5 | BlockExpr |
+| test.rs:299:13:299:26 | BreakExpr | test.rs:296:18:302:5 | BlockExpr |
+continueTarget
+| test.rs:19:17:19:24 | ContinueExpr | test.rs:10:9:22:9 | LoopExpr |
+| test.rs:45:21:45:28 | ContinueExpr | test.rs:43:13:50:13 | LoopExpr |
+| test.rs:47:21:47:35 | ContinueExpr | test.rs:41:9:51:9 | LoopExpr |
+| test.rs:49:17:49:31 | ContinueExpr | test.rs:43:13:50:13 | LoopExpr |
+| test.rs:59:21:59:28 | ContinueExpr | test.rs:57:13:64:13 | LoopExpr |
+| test.rs:61:21:61:34 | ContinueExpr | test.rs:57:13:64:13 | LoopExpr |
+| test.rs:63:17:63:30 | ContinueExpr | test.rs:57:13:64:13 | LoopExpr |

rust/ql/lib/codeql/rust/elements/internal/ContinueExprImpl.qll

@@ -1,3 +1,4 @@
+edges
 | variables.rs:1:1:3:1 | enter print_str | variables.rs:2:5:2:22 | ExprStmt |  |
 | variables.rs:1:1:3:1 | exit print_str (normal) | variables.rs:1:1:3:1 | exit print_str |  |
 | variables.rs:1:23:3:1 | BlockExpr | variables.rs:1:1:3:1 | exit print_str (normal) |  |
@@ -592,3 +593,5 @@
 | variables.rs:340:5:340:16 | PathExpr | variables.rs:340:5:340:18 | CallExpr |  |
 | variables.rs:340:5:340:18 | CallExpr | variables.rs:318:11:341:1 | BlockExpr |  |
 | variables.rs:340:5:340:19 | ExprStmt | variables.rs:340:5:340:16 | PathExpr |  |
+breakTarget
+continueTarget

rust/ql/test/library-tests/controlflow/Cfg.expected

@@ -7,3 +7,7 @@ class MyRelevantNode extends CfgNode {
 }
 
 import codeql.rust.controlflow.internal.ControlFlowGraphImpl::TestOutput<MyRelevantNode>
+
+query predicate breakTarget(BreakExpr be, Expr target) { target = be.getTarget() }
+
+query predicate continueTarget(ContinueExpr ce, Expr target) { target = ce.getTarget() }