Shared: Use shared SuccessorType in shared Cfg and BasicBlock libs.

Author: aschackmull

actions/ql/lib/codeql/actions/controlflow/internal/Cfg.qll

@@ -101,14 +101,8 @@ private module Implementation implements CfgShared::InputSig<Location> {
     last(scope.(CompositeAction), e, c)
   }
 
-  predicate successorTypeIsSimple(SuccessorType t) { t instanceof DirectSuccessor }
-
-  predicate successorTypeIsCondition(SuccessorType t) { t instanceof BooleanSuccessor }
-
   SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
 
-  predicate isAbnormalExitType(SuccessorType t) { none() }
-
   int idOfAstNode(AstNode node) { none() }
 
   int idOfCfgScope(CfgScope scope) { none() }

csharp/ql/lib/semmle/code/csharp/controlflow/internal/ControlFlowGraphImpl.qll

@@ -79,19 +79,10 @@ private module CfgInput implements CfgShared::InputSig<Location> {
     Impl::scopeLast(scope, last, c)
   }
 
-  class SuccessorType = ST::SuccessorType;
+  private class SuccessorType = ST::SuccessorType;
 
   SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
 
-  predicate successorTypeIsSimple(SuccessorType t) { t instanceof ST::DirectSuccessor }
-
-  predicate successorTypeIsCondition(SuccessorType t) { t instanceof ST::ConditionalSuccessor }
-
-  predicate isAbnormalExitType(SuccessorType t) {
-    t instanceof ST::ExceptionSuccessor or
-    t instanceof ST::ExitSuccessor
-  }
-
   int idOfAstNode(AstNode node) { result = node.getId() }
 
   int idOfCfgScope(CfgScope node) { result = idOfAstNode(node) }

java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll

@@ -7,13 +7,9 @@ module;
 import java
 import Dominance
 private import codeql.controlflow.BasicBlock as BB
+private import codeql.controlflow.SuccessorType
 
 private module Input implements BB::InputSig<Location> {
-  import codeql.controlflow.SuccessorType
-
-  /** Hold if `t` represents a conditional successor type. */
-  predicate successorTypeIsCondition(SuccessorType t) { none() }
-
   /** A delineated part of the AST with its own CFG. */
   class CfgScope = Callable;
 
@@ -96,7 +92,7 @@ class BasicBlock extends BbImpl::BasicBlock {
   predicate strictlyDominates(BasicBlock bb) { super.strictlyDominates(bb) }
 
   /** Gets an immediate successor of this basic block of a given type, if any. */
-  BasicBlock getASuccessor(Input::SuccessorType t) { result = super.getASuccessor(t) }
+  BasicBlock getASuccessor(SuccessorType t) { result = super.getASuccessor(t) }
 
   /**
    * DEPRECATED: Use `getASuccessor` instead.

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

@@ -46,19 +46,10 @@ private module CfgInput implements CfgShared::InputSig<Location> {
     scope.(Impl::CfgScopeImpl).exit(last, c)
   }
 
-  class SuccessorType = Cfg::SuccessorType;
+  private class SuccessorType = Cfg::SuccessorType;
 
   SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
 
-  predicate successorTypeIsSimple(SuccessorType t) { t instanceof Cfg::DirectSuccessor }
-
-  predicate successorTypeIsCondition(SuccessorType t) { t instanceof Cfg::ConditionalSuccessor }
-
-  predicate isAbnormalExitType(SuccessorType t) {
-    t instanceof Cfg::ExceptionSuccessor or
-    t instanceof Cfg::ExitSuccessor
-  }
-
   private predicate id(Ruby::AstNode node1, Ruby::AstNode node2) { node1 = node2 }
 
   private predicate idOf(Ruby::AstNode node, int id) = equivalenceRelation(id/2)(node, id)

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

@@ -29,22 +29,11 @@ private module CfgInput implements InputSig<Location> {
     Stages::CfgStage::ref()
   }
 
-  class SuccessorType = Cfg::SuccessorType;
+  private class SuccessorType = Cfg::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 Cfg::DirectSuccessor }
-
-  /** 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 Cfg::BooleanSuccessor }
-
   /** Holds if `first` is first executed when entering `scope`. */
   predicate scopeFirst(CfgScope scope, AstNode first) { scope.scopeFirst(first) }
 

shared/controlflow/codeql/controlflow/BasicBlock.qll

@@ -9,14 +9,10 @@ overlay[local?]
 module;
 
 private import codeql.util.Location
+private import SuccessorType
 
 /** Provides the language-specific input specification. */
 signature module InputSig<LocationSig Location> {
-  class SuccessorType;
-
-  /** Hold if `t` represents a conditional successor type. */
-  predicate successorTypeIsCondition(SuccessorType t);
-
   /** A delineated part of the AST with its own CFG. */
   class CfgScope;
 
@@ -320,7 +316,7 @@ module Make<LocationSig Location, InputSig<Location> Input> {
       //             --true--> [true] x and y --true--> foo
       //
       // and we want to ensure that both `foo` and `bar` start a new basic block.
-      exists(nodeGetAPredecessor(cfn, any(SuccessorType s | successorTypeIsCondition(s))))
+      exists(nodeGetAPredecessor(cfn, any(ConditionalSuccessor s)))
     }
 
     /**

shared/controlflow/codeql/controlflow/Cfg.qll

@@ -8,6 +8,7 @@ module;
 private import codeql.util.Location
 private import codeql.util.FileSystem
 private import codeql.util.Void
+private import SuccessorType
 
 /** Provides the language-specific input specification. */
 signature module InputSig<LocationSig Location> {
@@ -59,27 +60,9 @@ signature module InputSig<LocationSig Location> {
   /** Holds if `scope` is exited when `last` finishes with completion `c`. */
   predicate scopeLast(CfgScope scope, AstNode last, Completion c);
 
-  /** A type of a control flow successor. */
-  class SuccessorType {
-    /** Gets a textual representation of this successor type. */
-    string toString();
-  }
-
   /** Gets a successor type that matches completion `c`. */
   SuccessorType getAMatchingSuccessorType(Completion c);
 
-  /**
-   * Hold if `t` represents simple (normal) evaluation of a statement or an
-   * expression.
-   */
-  predicate successorTypeIsSimple(SuccessorType t);
-
-  /** Hold if `t` represents a conditional successor type. */
-  predicate successorTypeIsCondition(SuccessorType t);
-
-  /** Holds if `t` is an abnormal exit type out of a CFG scope. */
-  predicate isAbnormalExitType(SuccessorType t);
-
   /**
    * Gets an `id` of `node`. This is used to order the predecessors of a join
    * basic block.
@@ -522,7 +505,7 @@ module MakeWithSplitting<
   private predicate succEntrySplits(CfgScope pred, AstNode succ, Splits succSplits, SuccessorType t) {
     exists(int rnk |
       scopeFirst(pred, succ) and
-      successorTypeIsSimple(t) and
+      t instanceof DirectSuccessor and
       succEntrySplitsFromRank(pred, succ, succSplits, rnk)
     |
       rnk = 0 and
@@ -1016,7 +999,7 @@ module MakeWithSplitting<
       exists(CfgScope scope |
         pred = TAnnotatedExitNode(scope, _) and
         result = TExitNode(scope) and
-        successorTypeIsSimple(t)
+        t instanceof DirectSuccessor
       )
     }
 
@@ -1117,9 +1100,7 @@ module MakeWithSplitting<
     abstract Location getLocation();
 
     /** Holds if this control flow node has conditional successors. */
-    predicate isCondition() {
-      exists(this.getASuccessor(any(SuccessorType t | successorTypeIsCondition(t))))
-    }
+    predicate isCondition() { exists(this.getASuccessor(any(ConditionalSuccessor t))) }
 
     /** Gets the scope of this node. */
     CfgScope getScope() { result = getNodeCfgScope(this) }
@@ -1320,7 +1301,7 @@ module MakeWithSplitting<
       label =
         strictconcat(SuccessorType t, string s |
           succ = getASuccessor(pred, t) and
-          if successorTypeIsSimple(t) then s = "" else s = t.toString()
+          if t instanceof DirectSuccessor then s = "" else s = t.toString()
         |
           s, ", " order by s
         )
@@ -1590,10 +1571,6 @@ module MakeWithSplitting<
     private class NodeAlias = Node;
 
     private module BasicBlockInputSig implements BB::InputSig<Location> {
-      class SuccessorType = Input::SuccessorType;
-
-      predicate successorTypeIsCondition = Input::successorTypeIsCondition/1;
-
       class CfgScope = CfgScopeAlias;
 
       class Node = NodeAlias;

shared/controlflow/codeql/controlflow/SuccessorType.qll

@@ -296,3 +296,9 @@ class ExitSuccessor extends AbruptSuccessor, TExitSuccessor {
 class JumpSuccessor extends AbruptSuccessor, TJumpSuccessor {
   override string toString() { result = "jump" }
 }
+
+/** Holds if `t` is an abnormal exit type out of a CFG scope. */
+predicate isAbnormalExitType(SuccessorType t) {
+  t instanceof ExceptionSuccessor or
+  t instanceof ExitSuccessor
+}

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

@@ -48,28 +48,11 @@ module CfgInput implements InputSig<Location> {
 
   CfgScope getCfgScope(AstNode n) { result = scopeOfAst(n.asAstNode()) }
 
-  class SuccessorType = Cfg::SuccessorType;
+  private class SuccessorType = Cfg::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 Cfg::DirectSuccessor }
-
-  /** Holds if `t` is an abnormal exit type out of a CFG scope. */
-  predicate isAbnormalExitType(SuccessorType t) { t instanceof Cfg::ExceptionSuccessor }
-
-  /** Hold if `t` represents a conditional successor type. */
-  predicate successorTypeIsCondition(SuccessorType t) {
-    t instanceof Cfg::BooleanSuccessor or
-    t instanceof Cfg::JumpSuccessor or
-    t instanceof Cfg::MatchingSuccessor or
-    t instanceof Cfg::EmptinessSuccessor
-  }
-
   /** Holds if `first` is first executed when entering `scope`. */
   predicate scopeFirst(CfgScope scope, AstNode first) {
     scope.(Impl::CfgScope::Range_).entry(first)