Fix Rust shared CFG CI failures

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: hvitved

rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll

@@ -7,29 +7,30 @@ private import internal.ControlFlowGraphImpl as CfgImpl
 
 class BasicBlock = CfgImpl::Cfg::BasicBlock;
 
+/** A basic block containing the entry node of a callable. */
 final class EntryBasicBlock extends BasicBlock {
   EntryBasicBlock() { this.getFirstNode() instanceof CfgImpl::ControlFlow::EntryNode }
 }
 
+/** A basic block containing the final exit node of a callable. */
 final class ExitBasicBlock extends BasicBlock {
   ExitBasicBlock() { this.getLastNode() instanceof CfgImpl::ControlFlow::ExitNode }
 }
 
+/** A basic block containing an annotated normal or exceptional exit node. */
 final class AnnotatedExitBasicBlock extends BasicBlock {
-  AnnotatedExitBasicBlock() {
-    this.getANode() instanceof CfgImpl::ControlFlow::AnnotatedExitNode
-  }
+  AnnotatedExitBasicBlock() { this.getANode() instanceof CfgImpl::ControlFlow::AnnotatedExitNode }
 
   /** Holds if this block represents normal exit. */
-  predicate isNormal() {
-    this.getANode() instanceof CfgImpl::ControlFlow::NormalExitNode
-  }
+  predicate isNormal() { this.getANode() instanceof CfgImpl::ControlFlow::NormalExitNode }
 }
 
+/** A basic block whose last node is a condition. */
 final class ConditionBasicBlock extends BasicBlock {
   ConditionBasicBlock() { this.getLastNode().(ControlFlowGraph::CfgNode).isCondition() }
 }
 
+/** A basic block whose first node joins multiple predecessors. */
 final class JoinBasicBlock extends BasicBlock {
   JoinBasicBlock() { this.getFirstNode().(ControlFlowGraph::CfgNode).isJoin() }
 
@@ -46,6 +47,7 @@ final class JoinBasicBlock extends BasicBlock {
   }
 }
 
+/** A predecessor basic block of a join block. */
 final class JoinPredecessorBasicBlock extends BasicBlock {
   JoinPredecessorBasicBlock() { this.getASuccessor() instanceof JoinBasicBlock }
 }

rust/ql/lib/codeql/rust/controlflow/CfgNodes.qll

@@ -18,11 +18,11 @@ class AstCfgNode extends CfgNode {
   AstNode getAstNode() { this.injects(result) }
 }
 
-class ExitCfgNode extends CfgNode instanceof ControlFlow::ExitNode {
-}
+/** A CFG node representing the final exit from a callable. */
+class ExitCfgNode extends CfgNode instanceof ControlFlow::ExitNode { }
 
-class AnnotatedExitCfgNode extends CfgNode instanceof ControlFlow::AnnotatedExitNode {
-}
+/** A CFG node representing a normal or exceptional exit from a callable. */
+class AnnotatedExitCfgNode extends CfgNode instanceof ControlFlow::AnnotatedExitNode { }
 
 /** A variable access. */
 final class VariableAccessCfgNode extends PathExprBaseCfgNode {

rust/ql/lib/codeql/rust/controlflow/ControlFlowGraph.qll

@@ -13,9 +13,7 @@ class CfgNode extends CfgImpl::ControlFlowNode {
   CfgScope getScope() { result = this.getEnclosingCallable() }
 
   /** Holds if this node has conditional successors. */
-  predicate isCondition() {
-    exists(this.getASuccessor(any(ConditionalSuccessor t)))
-  }
+  predicate isCondition() { exists(this.getASuccessor(any(ConditionalSuccessor t))) }
 
   /** Holds if this node has more than one predecessor. */
   predicate isJoin() { strictcount(this.getAPredecessor()) > 1 }

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

@@ -13,9 +13,7 @@ private predicate successfullyExtractedFile(File f) {
   not exists(ExtractionWarning warning | warning.getLocation().getFile() = f)
 }
 
-query predicate missingCfgChild(
-  CfgImpl::ControlFlowNode parent, string pred, int i, AstNode child
-) {
+query predicate missingCfgChild(CfgImpl::ControlFlowNode parent, string pred, int i, AstNode child) {
   CfgNodes::missingCfgChild(parent, pred, i, child) and
   successfullyExtractedFile(child.getLocation().getFile())
 }

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

@@ -34,27 +34,19 @@ class MatchExprChildMapping extends ParentAstNode, MatchExpr {
 }
 
 class BlockExprChildMapping extends ParentAstNode, BlockExpr {
-  override predicate relevantChild(AstNode child) {
-    child = this.getStmtList().getTailExpr()
-  }
+  override predicate relevantChild(AstNode child) { child = this.getStmtList().getTailExpr() }
 }
 
 class BreakExprTargetChildMapping extends ParentAstNode, Expr {
-  override predicate relevantChild(AstNode child) {
-    child.(BreakExpr).getTarget() = this
-  }
+  override predicate relevantChild(AstNode child) { child.(BreakExpr).getTarget() = this }
 }
 
 class CallExprChildMapping extends ParentAstNode, CallExpr {
-  override predicate relevantChild(AstNode child) {
-    child = this.getArgList().getAnArg()
-  }
+  override predicate relevantChild(AstNode child) { child = this.getArgList().getAnArg() }
 }
 
 class MethodCallExprChildMapping extends ParentAstNode, MethodCallExpr {
-  override predicate relevantChild(AstNode child) {
-    child = this.getArgList().getAnArg()
-  }
+  override predicate relevantChild(AstNode child) { child = this.getArgList().getAnArg() }
 }
 
 class StructExprChildMapping extends ParentAstNode, StructExpr {
@@ -70,9 +62,7 @@ class StructPatChildMapping extends ParentAstNode, StructPat {
 }
 
 class MacroCallChildMapping extends ParentAstNode, MacroCall {
-  override predicate relevantChild(AstNode child) {
-    child = this.getMacroCallExpansion()
-  }
+  override predicate relevantChild(AstNode child) { child = this.getMacroCallExpansion() }
 }
 
 class FormatArgsExprChildMapping extends ParentAstNode, FormatArgsExpr {
@@ -104,9 +94,7 @@ class AssignmentExprChildMapping extends ParentAstNode, AssignmentExpr {
 }
 
 private class ChildMappingImpl extends ChildMapping {
-  override predicate hasCfgChild(
-    AstNode parent, AstNode child, AstCfgNode cfn, AstCfgNode cfnChild
-  ) {
+  override predicate hasCfgChild(AstNode parent, AstNode child, AstCfgNode cfn, AstCfgNode cfnChild) {
     Stages::CfgStage::ref() and
     this.relevantChild(parent, child) and
     cfn.getAstNode() = CfgNodesInput::getDesugared(parent) and

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

@@ -279,9 +279,7 @@ private module Ast implements AstSig<Location> {
     result = parent.(Rust::TupleStructPat).getField(index)
   }
 
-  AstNode getChild(AstNode parent, int index) {
-    result = desugar(runtimeChild(parent, index))
-  }
+  AstNode getChild(AstNode parent, int index) { result = desugar(runtimeChild(parent, index)) }
 
   private Callable getEnclosingCallableImpl(Rust::AstNode node) {
     exists(Rust::AstNode parent | parent = node.getParentNode() |
@@ -302,8 +300,7 @@ private module Ast implements AstSig<Location> {
 
   Callable getEnclosingCallable(AstNode node) { result = getEnclosingCallableImpl(node) }
 
-  class Callable extends AstNode instanceof Scope::CfgScope {
-  }
+  class Callable extends AstNode instanceof Scope::CfgScope { }
 
   AstNode callableGetBody(Callable c) {
     result = c.(Rust::Callable).getBody()
@@ -426,8 +423,7 @@ private module Ast implements AstSig<Location> {
     BreakStmt() { none() }
   }
 
-  class ContinueStmt extends Stmt instanceof Rust::ContinueExpr {
-  }
+  class ContinueStmt extends Stmt instanceof Rust::ContinueExpr { }
 
   class GotoStmt extends Stmt {
     GotoStmt() { none() }
@@ -503,11 +499,9 @@ private module Ast implements AstSig<Location> {
     Expr getRightOperand() { result = desugar(this.(Rust::BinaryExpr).getRhs()) }
   }
 
-  class LogicalAndExpr extends BinaryExpr instanceof Rust::LogicalAndExpr {
-  }
+  class LogicalAndExpr extends BinaryExpr instanceof Rust::LogicalAndExpr { }
 
-  class LogicalOrExpr extends BinaryExpr instanceof Rust::LogicalOrExpr {
-  }
+  class LogicalOrExpr extends BinaryExpr instanceof Rust::LogicalOrExpr { }
 
   class NullCoalescingExpr extends BinaryExpr {
     NullCoalescingExpr() { none() }
@@ -517,17 +511,13 @@ private module Ast implements AstSig<Location> {
     Expr getOperand() { result = desugar(this.(Rust::PrefixExpr).getExpr()) }
   }
 
-  class LogicalNotExpr extends UnaryExpr instanceof Rust::LogicalNotExpr {
-  }
+  class LogicalNotExpr extends UnaryExpr instanceof Rust::LogicalNotExpr { }
 
-  class Assignment extends BinaryExpr instanceof Rust::AssignmentOperation {
-  }
+  class Assignment extends BinaryExpr instanceof Rust::AssignmentOperation { }
 
-  class AssignExpr extends Assignment instanceof Rust::AssignmentExpr {
-  }
+  class AssignExpr extends Assignment instanceof Rust::AssignmentExpr { }
 
-  class CompoundAssignment extends Assignment instanceof Rust::CompoundAssignmentExpr {
-  }
+  class CompoundAssignment extends Assignment instanceof Rust::CompoundAssignmentExpr { }
 
   class AssignLogicalAndExpr extends CompoundAssignment {
     AssignLogicalAndExpr() { none() }
@@ -608,15 +598,11 @@ private predicate guaranteedMatch(Rust::Pat pat) {
 private module Input implements InputSig1, InputSig2 {
   private import codeql.util.Void
 
-  predicate cfgCachedStageRef() {
-    CfgCachedStage::ref()
-  }
+  predicate cfgCachedStageRef() { CfgCachedStage::ref() }
 
   private newtype TLabel =
     TTarget(Rust::Expr target) or
-    TTargetValue(Rust::Expr target, boolean value) {
-      value = true or value = false
-    }
+    TTargetValue(Rust::Expr target, boolean value) { value = true or value = false }
 
   class Label extends TLabel {
     string toString() {
@@ -804,17 +790,12 @@ private module Input implements InputSig1, InputSig2 {
       )
   }
 
-  private predicate isAfterMatch(
-    PreControlFlowNode n, Rust::AstNode ast, boolean value
-  ) {
-    n.isAfterValue(Ast::desugar(ast),
-      any(MatchingSuccessor t | t.getValue() = value))
+  private predicate isAfterMatch(PreControlFlowNode n, Rust::AstNode ast, boolean value) {
+    n.isAfterValue(Ast::desugar(ast), any(MatchingSuccessor t | t.getValue() = value))
   }
 
   private predicate parameterStep(PreControlFlowNode n1, PreControlFlowNode n2) {
-    exists(Rust::ParamBase p, Ast::AstNode child |
-      child = Ast::getChild(p, _)
-    |
+    exists(Rust::ParamBase p, Ast::AstNode child | child = Ast::getChild(p, _) |
       n1.isBefore(p) and n2.isBefore(child)
       or
       p instanceof Rust::Param and
@@ -864,15 +845,11 @@ private module Input implements InputSig1, InputSig2 {
     )
   }
 
-  private predicate matchArmStart(
-    Rust::MatchExpr match, int index, PreControlFlowNode n
-  ) {
+  private predicate matchArmStart(Rust::MatchExpr match, int index, PreControlFlowNode n) {
     n.isBefore(Ast::desugar(match.getArm(index).getPat()))
   }
 
-  private predicate matchArmBodyStart(
-    Rust::MatchArm arm, PreControlFlowNode n
-  ) {
+  private predicate matchArmBodyStart(Rust::MatchArm arm, PreControlFlowNode n) {
     n.isBefore(Ast::desugar(arm.getGuard().getCondition()))
     or
     not arm.hasGuard() and n.isBefore(Ast::desugar(arm.getExpr()))
@@ -914,9 +891,7 @@ private module Input implements InputSig1, InputSig2 {
     )
   }
 
-  private predicate genericPatternStep(
-    Rust::Pat pat, PreControlFlowNode n1, PreControlFlowNode n2
-  ) {
+  private predicate genericPatternStep(Rust::Pat pat, PreControlFlowNode n1, PreControlFlowNode n2) {
     not pat instanceof Rust::IdentPat and
     not pat instanceof Rust::LiteralPat and
     not pat instanceof Rust::OrPat and
@@ -981,9 +956,7 @@ private module Input implements InputSig1, InputSig2 {
     n1.isIn(pat) and not guaranteedMatch(pat) and isAfterMatch(n2, pat, false)
   }
 
-  private predicate orPatternStep(
-    Rust::OrPat pat, PreControlFlowNode n1, PreControlFlowNode n2
-  ) {
+  private predicate orPatternStep(Rust::OrPat pat, PreControlFlowNode n1, PreControlFlowNode n2) {
     n1.isBefore(pat) and n2.isBefore(Ast::desugar(getRankedPatternChild(pat, 1)))
     or
     exists(int i, Rust::Pat child | child = getRankedPatternChild(pat, i) |
@@ -1002,13 +975,16 @@ private module Input implements InputSig1, InputSig2 {
 
   private predicate patternStep(PreControlFlowNode n1, PreControlFlowNode n2) {
     exists(Rust::Pat pat |
-      genericPatternStep(pat, n1, n2)
-      or
-      literalPatternStep(pat, n1, n2)
-      or
-      identPatternStep(pat, n1, n2)
-      or
-      orPatternStep(pat, n1, n2)
+      Ast::desugar(pat) = pat and
+      (
+        genericPatternStep(pat, n1, n2)
+        or
+        literalPatternStep(pat, n1, n2)
+        or
+        identPatternStep(pat, n1, n2)
+        or
+        orPatternStep(pat, n1, n2)
+      )
     )
   }
 
@@ -1110,15 +1086,11 @@ private module Input implements InputSig1, InputSig2 {
     always = true
   }
 
-  private predicate targetChild(
-    Rust::Expr target, Ast::AstNode child
-  ) {
+  private predicate targetChild(Rust::Expr target, Ast::AstNode child) {
     child = Ast::getChild(target, _)
   }
 
-  predicate endAbruptCompletion(
-    Ast::AstNode ast, PreControlFlowNode n, AbruptCompletion c
-  ) {
+  predicate endAbruptCompletion(Ast::AstNode ast, PreControlFlowNode n, AbruptCompletion c) {
     exists(Rust::Expr target |
       targetChild(target, ast) and
       c.getSuccessorType() instanceof BreakSuccessor

rust/ql/src/queries/unusedentities/UnreachableCode.ql

@@ -30,19 +30,13 @@ private AstNode desugar(AstNode n) {
  *
  * The shared control-flow library only creates nodes for reachable code.
  */
-private predicate reachable(AstNode n) {
-  any(CfgNode cfg).getAstNode() = desugar(n)
-}
+private predicate reachable(AstNode n) { any(CfgNode cfg).getAstNode() = desugar(n) }
 
 /** Holds if normal execution of `n` reaches its after-node. */
-private predicate reachesAfter(AstNode n) {
-  any(CfgNode cfg).isAfter(desugar(n))
-}
+private predicate reachesAfter(AstNode n) { any(CfgNode cfg).isAfter(desugar(n)) }
 
 /** Holds if `n` is a direct element of a statement list. */
-private predicate statementListElement(AstNode n) {
-  n = any(StmtList list).getStmtOrExpr(_)
-}
+private predicate statementListElement(AstNode n) { n = any(StmtList list).getStmtOrExpr(_) }
 
 /** Holds if `n` is a statement-list element that executes at runtime. */
 private predicate runtimeStatementListElement(AstNode n) {