Make more classes private and final

Author: paldepind

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

@@ -1,16 +1,17 @@
 private import rust
 private import ControlFlowGraph
 private import internal.SuccessorType
-private import SuccessorTypes
 private import internal.ControlFlowGraphImpl as Impl
 private import codeql.rust.generated.Raw
 private import codeql.rust.generated.Synth
 
+final class BasicBlock = BasicBlockImpl;
+
 /**
  * A basic block, that is, a maximal straight-line sequence of control flow nodes
  * without branches or joins.
  */
-class BasicBlock extends TBasicBlockStart {
+private class BasicBlockImpl extends TBasicBlockStart {
   /** Gets the scope of this basic block. */
   CfgScope getScope() { result = this.getAPredecessor().getScope() }
 
@@ -163,7 +164,7 @@ private predicate entryBB(BasicBlock bb) { bb.getFirstNode() instanceof Impl::En
  * An entry basic block, that is, a basic block whose first node is
  * an entry node.
  */
-class EntryBasicBlock extends BasicBlock {
+class EntryBasicBlock extends BasicBlockImpl {
   EntryBasicBlock() { entryBB(this) }
 
   override CfgScope getScope() {
@@ -175,7 +176,7 @@ class EntryBasicBlock extends BasicBlock {
  * An annotated exit basic block, that is, a basic block whose last node is
  * an annotated exit node.
  */
-class AnnotatedExitBasicBlock extends BasicBlock {
+class AnnotatedExitBasicBlock extends BasicBlockImpl {
   private boolean normal;
 
   AnnotatedExitBasicBlock() {
@@ -193,7 +194,7 @@ class AnnotatedExitBasicBlock extends BasicBlock {
  * An exit basic block, that is, a basic block whose last node is
  * an exit node.
  */
-class ExitBasicBlock extends BasicBlock {
+class ExitBasicBlock extends BasicBlockImpl {
   ExitBasicBlock() { this.getLastNode() instanceof Impl::ExitNode }
 }
 
@@ -220,7 +221,7 @@ private module JoinBlockPredecessors {
 }
 
 /** A basic block with more than one predecessor. */
-class JoinBlock extends BasicBlock {
+class JoinBlock extends BasicBlockImpl {
   JoinBlock() { this.getFirstNode().isJoin() }
 
   /**
@@ -231,12 +232,12 @@ class JoinBlock extends BasicBlock {
 }
 
 /** A basic block that is an immediate predecessor of a join block. */
-class JoinBlockPredecessor extends BasicBlock {
+class JoinBlockPredecessor extends BasicBlockImpl {
   JoinBlockPredecessor() { this.getASuccessor() instanceof JoinBlock }
 }
 
 /** A basic block that terminates in a condition, splitting the subsequent control flow. */
-class ConditionBlock extends BasicBlock {
+class ConditionBlock extends BasicBlockImpl {
   ConditionBlock() { this.getLastNode().isCondition() }
 
   /**

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

@@ -5,7 +5,9 @@ private import internal.ControlFlowGraphImpl
 private import internal.Completion
 private import internal.SuccessorType
 private import codeql.rust.controlflow.BasicBlocks
-import internal.Scope
+private import internal.Scope as Scope
+
+final class CfgScope = Scope::CfgScope;
 
 /**
  * A control flow node.
@@ -15,21 +17,21 @@ import internal.Scope
  *
  * Only nodes that can be reached from an entry point are included in the CFG.
  */
-class CfgNode extends Node {
+final class CfgNode extends Node {
   /** Gets the file of this control flow node. */
-  final File getFile() { result = this.getLocation().getFile() }
+  File getFile() { result = this.getLocation().getFile() }
 
   /** Gets a successor node of a given type, if any. */
-  final CfgNode getASuccessor(SuccessorType t) { result = super.getASuccessor(t) }
+  CfgNode getASuccessor(SuccessorType t) { result = super.getASuccessor(t) }
 
   /** Gets an immediate successor, if any. */
-  final CfgNode getASuccessor() { result = this.getASuccessor(_) }
+  CfgNode getASuccessor() { result = this.getASuccessor(_) }
 
   /** Gets an immediate predecessor node of a given flow type, if any. */
-  final CfgNode getAPredecessor(SuccessorType t) { result.getASuccessor(t) = this }
+  CfgNode getAPredecessor(SuccessorType t) { result.getASuccessor(t) = this }
 
   /** Gets an immediate predecessor, if any. */
-  final CfgNode getAPredecessor() { result = this.getAPredecessor(_) }
+  CfgNode getAPredecessor() { result = this.getAPredecessor(_) }
 
   /** Gets the basic block that this control flow node belongs to. */
   BasicBlock getBasicBlock() { result.getANode() = this }

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

@@ -2,7 +2,6 @@ private import codeql.util.Boolean
 private import codeql.rust.controlflow.ControlFlowGraph
 private import rust
 private import SuccessorType
-private import SuccessorTypes
 
 private newtype TCompletion =
   TSimpleCompletion() or
@@ -63,7 +62,7 @@ abstract class ConditionalCompletion extends NormalCompletion {
 class BooleanCompletion extends ConditionalCompletion, TBooleanCompletion {
   BooleanCompletion() { this = TBooleanCompletion(value) }
 
-  override predicate isValidForSpecific(AstNode e) { e = any(If c).getCondition() }
+  override predicate isValidForSpecific(AstNode e) { e = any(IfExpr c).getCondition() }
 
   /** Gets the dual Boolean completion. */
   override BooleanCompletion getDual() { result = TBooleanCompletion(value.booleanNot()) }
@@ -79,7 +78,7 @@ class BooleanCompletion extends ConditionalCompletion, TBooleanCompletion {
 class ReturnCompletion extends TReturnCompletion, Completion {
   override ReturnSuccessor getAMatchingSuccessorType() { any() }
 
-  override predicate isValidForSpecific(AstNode e) { e instanceof Return }
+  override predicate isValidForSpecific(AstNode e) { e instanceof ReturnExpr }
 
   override string toString() { result = "return" }
 }

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

@@ -1,23 +1,101 @@
 private import rust
-import ControlFlowGraphImplSpecific::CfgImpl
+import codeql.controlflow.Cfg
 import Completion
+import codeql.controlflow.Cfg
+private import SuccessorType as ST
+private import Scope as Scope
 
-class CallTree extends StandardPostOrderTree instanceof Call {
+module CfgInput implements InputSig<Location> {
+  private import rust as Rust
+  private import Completion as C
+  private import Splitting as S
+
+  class AstNode = Rust::AstNode;
+
+  class Completion = C::Completion;
+
+  predicate completionIsNormal = C::completionIsNormal/1;
+
+  predicate completionIsSimple = C::completionIsSimple/1;
+
+  predicate completionIsValidFor = C::completionIsValidFor/2;
+
+  /** An AST node with an associated control-flow graph. */
+  class CfgScope = Scope::CfgScope;
+
+  CfgScope getCfgScope(AstNode n) { result = Scope::scopeOfAst(n) }
+
+  class SplitKindBase = S::TSplitKind;
+
+  class Split = S::Split;
+
+  class SuccessorType = ST::SuccessorType;
+
+  /** Gets a successor type that matches completion `c`. */
+  SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
+
+  /**
+   * Hold if `c` represents simple (normal) evaluation of a statement or an expression.
+   */
+  predicate successorTypeIsSimple(SuccessorType t) { t instanceof ST::NormalSuccessor }
+
+  /** Holds if `t` is an abnormal exit type out of a CFG scope. */
+  predicate isAbnormalExitType(SuccessorType t) { none() }
+
+  /** Hold if `t` represents a conditional successor type. */
+  predicate successorTypeIsCondition(SuccessorType t) { t instanceof ST::BooleanSuccessor }
+
+  /** Gets the maximum number of splits allowed for a given node. */
+  int maxSplits() { result = 0 }
+
+  /** Holds if `first` is first executed when entering `scope`. */
+  predicate scopeFirst(CfgScope scope, AstNode first) {
+    scope.(CfgImpl::ControlFlowTree).first(first)
+  }
+
+  /** Holds if `scope` is exited when `last` finishes with completion `c`. */
+  predicate scopeLast(CfgScope scope, AstNode last, Completion c) {
+    scope.(CfgImpl::ControlFlowTree).last(last, c)
+  }
+}
+
+module CfgImpl = Make<Location, CfgInput>;
+
+import CfgImpl
+
+class FunctionTree extends LeafTree instanceof Function { }
+
+class BlockExprTree extends StandardPostOrderTree instanceof BlockExpr {
+  override ControlFlowTree getChildNode(int i) {
+    result = super.getStatement(i)
+    or
+    exists(int last |
+      last + 1 = i and
+      exists(super.getStatement(last)) and
+      not exists(super.getStatement(last + 1)) and
+      result = super.getTail()
+    )
+  }
+}
+
+class CallExprTree extends StandardPostOrderTree instanceof CallExpr {
   override ControlFlowTree getChildNode(int i) { result = super.getArg(i) }
 }
 
-class BinaryOpTree extends StandardPostOrderTree instanceof BinaryOp {
+class BinaryOpExprTree extends StandardPostOrderTree instanceof BinaryOpExpr {
   override ControlFlowTree getChildNode(int i) {
     i = 0 and result = super.getLhs()
     or
     i = 1 and result = super.getRhs()
   }
 }
 
-class IfTree extends PostOrderTree instanceof If {
+class IfExprTree extends PostOrderTree instanceof IfExpr {
   override predicate first(AstNode node) { first(super.getCondition(), node) }
 
-  override predicate propagatesAbnormal(AstNode child) { none() }
+  override predicate propagatesAbnormal(AstNode child) {
+    child = [super.getCondition(), super.getThen(), super.getElse()]
+  }
 
   override predicate succ(AstNode pred, AstNode succ, Completion c) {
     // Edges from the condition to each branch
@@ -31,17 +109,17 @@ class IfTree extends PostOrderTree instanceof If {
     // An edge from the then branch to the last node
     last(super.getThen(), pred, c) and
     succ = this and
-    completionIsSimple(c)
+    completionIsNormal(c)
     or
     // An edge from the else branch to the last node
     last(super.getElse(), pred, c) and
     succ = this and
-    completionIsSimple(c)
+    completionIsNormal(c)
   }
 }
 
-class LetTree extends StandardPostOrderTree instanceof Let {
+class LetExprTree extends StandardPostOrderTree instanceof LetExpr {
   override ControlFlowTree getChildNode(int i) { i = 0 and result = super.getExpr() }
 }
 
-class LiteralTree extends LeafTree instanceof Literal { }
+class LiteralExprTree extends LeafTree instanceof LiteralExpr { }

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

@@ -33,7 +33,7 @@ external int selectedSourceColumn();
 
 private predicate selectedSourceColumnAlias = selectedSourceColumn/0;
 
-module ViewCfgQueryInput implements Impl::ViewCfgQueryInputSig<File> {
+private module ViewCfgQueryInput implements Impl::ViewCfgQueryInputSig<File> {
   predicate selectedSourceFile = selectedSourceFileAlias/0;
 
   predicate selectedSourceLine = selectedSourceLineAlias/0;

rust/ql/lib/codeql/rust/controlflow/internal/PrintCFG.ql renamed to rust/ql/lib/codeql/rust/controlflow/internal/PrintCfg.ql

@@ -6,23 +6,21 @@ abstract class CfgScope extends AstNode { }
 
 class FunctionScope extends CfgScope, Function { }
 
-cached
-private module Cached {
-  /**
-   * Gets the immediate parent of a non-`AstNode` element `e`.
-   *
-   * We restrict `e` to be a non-`AstNode` to skip past non-`AstNode` in
-   * the transitive closure computation in `getParentOfAst`. This is
-   * necessary because the parent of an `AstNode` is not necessarily an `AstNode`.
-   */
-  private Element getParentOfAstStep(Element e) {
-    not e instanceof AstNode and
-    result = getImmediateParent(e)
-  }
+/**
+ * Gets the immediate parent of a non-`AstNode` element `e`.
+ *
+ * We restrict `e` to be a non-`AstNode` to skip past non-`AstNode` in
+ * the transitive closure computation in `getParentOfAst`. This is
+ * necessary because the parent of an `AstNode` is not necessarily an `AstNode`.
+ */
+private Element getParentOfAstStep(Element e) {
+  not e instanceof AstNode and
+  result = getImmediateParent(e)
+}
 
-  /** Gets the nearest enclosing parent of `ast` that is an `AstNode`. */
-  cached
-  AstNode getParentOfAst(AstNode ast) { result = getParentOfAstStep*(getImmediateParent(ast)) }
+/** Gets the nearest enclosing parent of `ast` that is an `AstNode`. */
+private AstNode getParentOfAst(AstNode ast) {
+  result = getParentOfAstStep*(getImmediateParent(ast))
 }
 
 /** Gets the enclosing scope of a node */
@@ -32,5 +30,3 @@ AstNode scopeOfAst(AstNode n) {
     if p instanceof CfgScope then p = result else result = scopeOfAst(p)
   )
 }
-
-import Cached