Data flow: Sync files

cpp/ql/lib/semmle/code/cpp/dataflow/internal/DataFlowImpl.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/dataflow/internal/DataFlowImpl2.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/dataflow/internal/DataFlowImpl3.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/dataflow/internal/DataFlowImpl4.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/dataflow/internal/DataFlowImplLocal.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl2.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl3.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowImpl4.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowImpl2.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowImpl3.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowImpl4.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowImpl5.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImpl.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImpl2.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImpl3.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImpl4.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImpl5.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImpl6.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImplForOnActivityResult.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

java/ql/lib/semmle/code/java/dataflow/internal/DataFlowImplForSerializability.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

python/ql/lib/semmle/python/dataflow/new/internal/DataFlowImpl.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

python/ql/lib/semmle/python/dataflow/new/internal/DataFlowImpl2.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

python/ql/lib/semmle/python/dataflow/new/internal/DataFlowImpl3.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

python/ql/lib/semmle/python/dataflow/new/internal/DataFlowImpl4.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

ruby/ql/lib/codeql/ruby/dataflow/internal/DataFlowImpl.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

ruby/ql/lib/codeql/ruby/dataflow/internal/DataFlowImpl2.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }
 

ruby/ql/lib/codeql/ruby/dataflow/internal/DataFlowImplForLibraries.qll

@@ -4300,6 +4300,12 @@ private module Subpaths {
     )
   }
 
+  pragma[nomagic]
+  private predicate hasSuccessor(PathNode pred, PathNodeMid succ, NodeEx succNode) {
+    succ = pred.getASuccessor() and
+    succNode = succ.getNodeEx()
+  }
+
   /**
    * Holds if `(arg, par, ret, out)` forms a subpath-tuple, that is, flow through
    * a subpath between `par` and `ret` with the connecting edges `arg -> par` and
@@ -4307,15 +4313,13 @@ private module Subpaths {
    */
   predicate subpaths(PathNode arg, PathNodeImpl par, PathNodeImpl ret, PathNode out) {
     exists(ParamNodeEx p, NodeEx o, FlowState sout, AccessPath apout, PathNodeMid out0 |
-      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](par) and
+      pragma[only_bind_into](arg).getASuccessor() = pragma[only_bind_into](out0) and
-      pragma[only_bind_into](arg).getASuccessor() = out0 and
       subpaths03(pragma[only_bind_into](arg), p, localStepToHidden*(ret), o, sout, apout) and
+      hasSuccessor(pragma[only_bind_into](arg), par, p) and
       not ret.isHidden() and
-      par.getNodeEx() = p and
+      pathNode(out0, o, sout, _, _, apout, _, _)
-      out0.getNodeEx() = o and
+    |
-      out0.getState() = sout and
+      out = out0 or out = out0.projectToSink()
-      out0.getAp() = apout and
-      (out = out0 or out = out0.projectToSink())
     )
   }