Rename succSimple to succ0

Author: owen-mc

go/ql/lib/semmle/go/controlflow/ControlFlowGraphImpl.qll

@@ -623,14 +623,14 @@ module CFG {
       not cmpl.isNormal()
     }
 
-    predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       exists(int i |
         lastNode(this.getChildTreeRanked(i), pred, normalCompletion()) and
         firstNode(this.getChildTreeRanked(i + 1), succ)
       )
     }
 
-    predicate succ(ControlFlow::Node pred, ControlFlow::Node succ) { this.succSimple(pred, succ) }
+    predicate succ(ControlFlow::Node pred, ControlFlow::Node succ) { this.succ0(pred, succ) }
 
     final ControlFlowTree getChildTreeRanked(int i) {
       exists(int j |
@@ -729,8 +729,8 @@ module CFG {
       last = this.getNode() and cmpl = this.getCompletion()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      super.succ0(pred, succ)
       or
       lastNode(this.getLastChildTree(), pred, normalCompletion()) and
       succ = this.getNode()
@@ -752,8 +752,8 @@ module CFG {
       cmpl = Done()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      super.succ0(pred, succ)
       or
       pred = this.getNode() and
       firstNode(this.getFirstChildTree(), succ)
@@ -855,8 +855,8 @@ module CFG {
       cmpl = Done()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       exists(int i | lastNode(this.getLhs(i), pred, normalCompletion()) |
         firstNode(this.getLhs(i + 1), succ)
@@ -980,7 +980,7 @@ module CFG {
       )
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       exists(Completion lcmpl |
         lastNode(this.getLeftOperand(), pred, lcmpl) and
         succ = this.getGuard(lcmpl.getOutcome())
@@ -1030,11 +1030,11 @@ module CFG {
       not result instanceof TypeExpr
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       // interpose implicit argument destructuring nodes between last argument
       // and call itself; this is for cases like `f(g())` where `g` has multiple
       // results
-      exists(ControlFlow::Node mid | PostOrderTree.super.succSimple(pred, mid) |
+      exists(ControlFlow::Node mid | PostOrderTree.super.succ0(pred, mid) |
         if mid = this.getNode() then succ = this.getEpilogueNode(0) else succ = mid
       )
       or
@@ -1104,8 +1104,8 @@ module CFG {
       lastNode(this.getStmt(this.getNumStmt() - 1), last, cmpl)
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       exists(int i |
         lastNode(this.getExpr(i), pred, normalCompletion()) and
@@ -1174,7 +1174,7 @@ module CFG {
       cmpl = Done()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       this.firstNode(pred) and
       succ = this.getElementStart(0)
       or
@@ -1252,7 +1252,7 @@ module CFG {
       cmpl = Done()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       lastNode(this.getInit(), pred, normalCompletion()) and
       firstNode(this.getCond(), succ)
       or
@@ -1283,7 +1283,7 @@ module CFG {
       (cmpl = Done() or cmpl = Panic())
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       lastNode(this.getBase(), pred, normalCompletion()) and
       (
         succ = MkImplicitDeref(this.getBase())
@@ -1320,8 +1320,8 @@ module CFG {
 
     override predicate lastNode(ControlFlow::Node last, Completion cmpl) { none() }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       pred = MkEntryNode(this) and
       firstNode(this.getDecl(0), succ)
@@ -1376,7 +1376,7 @@ module CFG {
       i = 5 and result = this.getBody()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       exists(int i, ControlFlowTree predTree, Completion cmpl |
         predTree = this.getChildTreeRanked(i) and
         lastNode(predTree, pred, cmpl) and
@@ -1442,13 +1442,13 @@ module CFG {
         // `defer` can be the first `defer` statement executed
         // there is always a predecessor node because the `defer`'s call is always
         // evaluated before the defer statement itself
-        MkDeferNode(defer) = succSimple(notDeferSuccSimple*(this.getEntry()))
+        MkDeferNode(defer) = succ0(notDefersucc0*(this.getEntry()))
       )
     }
 
     override predicate lastNode(ControlFlow::Node last, Completion cmpl) { none() }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       exists(int i |
         pred = this.getPrologueNode(i) and
         succ = this.getPrologueNode(i + 1)
@@ -1469,12 +1469,12 @@ module CFG {
     }
 
     override predicate succ(ControlFlow::Node pred, ControlFlow::Node succ) {
-      this.succSimple(pred, succ)
+      this.succ0(pred, succ)
       or
       exists(Completion cmpl |
         lastNode(this.getBody(), pred, cmpl) and
         // last node of function body can be reached without going through a `defer` statement
-        pred = notDeferSuccSimple*(this.getEntry())
+        pred = notDefersucc0*(this.getEntry())
       |
         // panic goes directly to exit, non-panic reads result variables first
         if cmpl = Panic() then succ = MkExitNode(this) else succ = this.getEpilogueNode(0)
@@ -1484,7 +1484,7 @@ module CFG {
       exists(DeferStmt defer | defer = this.getADeferStmt() |
         succ = MkExprNode(defer.getCall()) and
         // the last `DeferStmt` executed before pred is this `defer`
-        pred = notDeferSuccSimple*(MkDeferNode(defer))
+        pred = notDefersucc0*(MkDeferNode(defer))
       )
       or
       exists(DeferStmt predDefer, DeferStmt succDefer |
@@ -1522,7 +1522,7 @@ module CFG {
       cmpl = Done()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       lastNode(this.getOperand(), pred, normalCompletion()) and
       succ = MkImplicitOne(this)
       or
@@ -1553,7 +1553,7 @@ module CFG {
       not cmpl.isNormal()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       lastNode(this.getDomain(), pred, normalCompletion()) and
       succ = MkNextNode(this)
       or
@@ -1628,7 +1628,7 @@ module CFG {
 
     override Completion getCompletion() { result = Return() }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       exists(int i |
         lastNode(this.getExpr(i), pred, normalCompletion()) and
         succ = this.complete(i)
@@ -1684,8 +1684,8 @@ module CFG {
       )
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       exists(CommClause cc, int i, Stmt comm |
         cc = this.getNonDefaultCommClause(i) and
@@ -1783,7 +1783,7 @@ module CFG {
       cmpl = Done()
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
       exists(int i | pred = this.getStepWithRank(i) and succ = this.getStepWithRank(i + 1))
     }
 
@@ -1820,8 +1820,8 @@ module CFG {
       (cmpl = Done() or cmpl = Panic())
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       not this = any(CommClause cc).getComm() and
       lastNode(this.getValue(), pred, normalCompletion()) and
@@ -1849,8 +1849,8 @@ module CFG {
       (cmpl = Done() or cmpl = Panic())
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       lastNode(this.getBase(), pred, normalCompletion()) and
       (
@@ -1936,8 +1936,8 @@ module CFG {
       )
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       lastNode(this.getInit(), pred, normalCompletion()) and
       (
@@ -2010,8 +2010,8 @@ module CFG {
       )
     }
 
-    override predicate succSimple(ControlFlow::Node pred, ControlFlow::Node succ) {
-      ControlFlowTree.super.succSimple(pred, succ)
+    override predicate succ0(ControlFlow::Node pred, ControlFlow::Node succ) {
+      ControlFlowTree.super.succ0(pred, succ)
       or
       not this = any(RecvStmt recv).getExpr() and
       lastNode(this.getOperand(), pred, normalCompletion()) and
@@ -2039,19 +2039,19 @@ module CFG {
   }
 
   /** Gets a successor of `nd` that is not a `defer` node */
-  private ControlFlow::Node notDeferSuccSimple(ControlFlow::Node nd) {
+  private ControlFlow::Node notDefersucc0(ControlFlow::Node nd) {
     not result = MkDeferNode(_) and
-    result = succSimple(nd)
+    result = succ0(nd)
   }
 
   /** Gets `defer` statements that can be the first defer statement after `nd` in the CFG */
   private ControlFlow::Node nextDefer(ControlFlow::Node nd) {
     nd = MkDeferNode(_) and
     result = MkDeferNode(_) and
     (
-      result = succSimple(nd)
+      result = succ0(nd)
       or
-      result = succSimple(notDeferSuccSimple+(nd))
+      result = succ0(notDefersucc0+(nd))
     )
   }
 
@@ -2082,9 +2082,7 @@ module CFG {
 
   /** Gets a successor of `nd`, that is, a node that is executed after `nd`. */
   cached
-  ControlFlow::Node succSimple(ControlFlow::Node nd) {
-    any(ControlFlowTree tree).succSimple(nd, result)
-  }
+  ControlFlow::Node succ0(ControlFlow::Node nd) { any(ControlFlowTree tree).succ0(nd, result) }
 
   /** Gets a successor of `nd`, that is, a node that is executed after `nd`. */
   cached