SSA: Update input to use member predicates.

aschackmull · aschackmull · commit bb3abc815f52 · 2025-09-01T11:19:48.000+02:00
diff --git a/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/SsaImplCommon.qll b/cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/SsaImplCommon.qll
@@ -778,11 +778,13 @@ module InputSigCommon {
     ControlFlowNode getNode(int i) { result = this.getInstruction(i) }
 
     int length() { result = this.getInstructionCount() }
-  }
 
-  class ControlFlowNode = Instruction;
+    BasicBlock getASuccessor() { result = super.getASuccessor() }
 
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result.immediatelyDominates(bb) }
+    BasicBlock getImmediateDominator() { result.immediatelyDominates(this) }
 
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
+    predicate inDominanceFrontier(BasicBlock df) { super.dominanceFrontier() = df }
+  }
+
+  class ControlFlowNode = Instruction;
 }
diff --git a/csharp/ql/consistency-queries/CfgConsistency.ql b/csharp/ql/consistency-queries/CfgConsistency.ql
@@ -45,8 +45,8 @@ predicate bbIntraSuccInconsistency(ControlFlowElement pred, ControlFlowElement s
     bb.getASuccessor().getFirstElement() = succ
   ) and
   not exists(PreBasicBlock bb, int i |
-    bb.getElement(i) = pred and
-    bb.getElement(i + 1) = succ
+    bb.getNode(i) = pred and
+    bb.getNode(i + 1) = succ
   )
 }
 
diff --git a/csharp/ql/lib/semmle/code/csharp/controlflow/BasicBlocks.qll b/csharp/ql/lib/semmle/code/csharp/controlflow/BasicBlocks.qll
@@ -58,6 +58,8 @@ final class BasicBlock extends BasicBlocksImpl::BasicBlock {
     result.getFirstNode() = this.getLastNode().getAFalseSuccessor()
   }
 
+  BasicBlock getASuccessor() { result = super.getASuccessor() }
+
   /** Gets the control flow node at a specific (zero-indexed) position in this basic block. */
   ControlFlow::Node getNode(int pos) { result = super.getNode(pos) }
 
diff --git a/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll b/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll
@@ -63,16 +63,20 @@ class PreBasicBlock extends ControlFlowElement {
 
   PreBasicBlock getAPredecessor() { result.getASuccessor() = this }
 
-  ControlFlowElement getElement(int pos) { bbIndex(this, result, pos) }
+  ControlFlowElement getNode(int pos) { bbIndex(this, result, pos) }
 
-  ControlFlowElement getAnElement() { result = this.getElement(_) }
+  deprecated ControlFlowElement getElement(int pos) { result = this.getNode(pos) }
+
+  ControlFlowElement getAnElement() { result = this.getNode(_) }
 
   ControlFlowElement getFirstElement() { result = this }
 
-  ControlFlowElement getLastElement() { result = this.getElement(this.length() - 1) }
+  ControlFlowElement getLastElement() { result = this.getNode(this.length() - 1) }
 
   int length() { result = strictcount(this.getAnElement()) }
 
+  PreBasicBlock getImmediateDominator() { bbIDominates(result, this) }
+
   predicate immediatelyDominates(PreBasicBlock bb) { bbIDominates(this, bb) }
 
   pragma[inline]
@@ -84,6 +88,15 @@ class PreBasicBlock extends ControlFlowElement {
     or
     this.strictlyDominates(bb)
   }
+
+  predicate inDominanceFrontier(PreBasicBlock df) {
+    this = df.getAPredecessor() and not bbIDominates(this, df)
+    or
+    exists(PreBasicBlock prev | prev.inDominanceFrontier(df) |
+      bbIDominates(this, prev) and
+      not bbIDominates(this, df)
+    )
+  }
 }
 
 private Completion getConditionalCompletion(ConditionalCompletion cc) {
diff --git a/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreSsa.qll b/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreSsa.qll
@@ -14,7 +14,7 @@ module PreSsa {
   private predicate definitionAt(
     AssignableDefinition def, SsaInput::BasicBlock bb, int i, SsaInput::SourceVariable v
   ) {
-    bb.getElement(i) = def.getExpr() and
+    bb.getNode(i) = def.getExpr() and
     v = def.getTarget() and
     // In cases like `(x, x) = (0, 1)`, we discard the first (dead) definition of `x`
     not exists(TupleAssignmentDefinition first, TupleAssignmentDefinition second | first = def |
@@ -80,16 +80,10 @@ module PreSsa {
   }
 
   module SsaInput implements SsaImplCommon::InputSig<Location> {
-    class BasicBlock extends PreBasicBlocks::PreBasicBlock {
-      ControlFlowNode getNode(int i) { result = this.getElement(i) }
-    }
+    class BasicBlock = PreBasicBlocks::PreBasicBlock;
 
     class ControlFlowNode = ControlFlowElement;
 
-    BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result.immediatelyDominates(bb) }
-
-    BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
-
     private class ExitBasicBlock extends BasicBlock {
       ExitBasicBlock() { scopeLast(_, this.getLastElement(), _) }
     }
@@ -142,7 +136,7 @@ module PreSsa {
 
     predicate variableRead(BasicBlock bb, int i, SourceVariable v, boolean certain) {
       exists(AssignableRead read |
-        read = bb.getElement(i) and
+        read = bb.getNode(i) and
         read.getTarget() = v and
         certain = true
       )
@@ -163,7 +157,7 @@ module PreSsa {
     final AssignableRead getARead() {
       exists(SsaInput::BasicBlock bb, int i |
         SsaImpl::ssaDefReachesRead(_, this, bb, i) and
-        result = bb.getElement(i)
+        result = bb.getNode(i)
       )
     }
 
@@ -177,7 +171,7 @@ module PreSsa {
     final AssignableRead getAFirstRead() {
       exists(SsaInput::BasicBlock bb, int i |
         SsaImpl::firstUse(this, bb, i, true) and
-        result = bb.getElement(i)
+        result = bb.getNode(i)
       )
     }
 
@@ -214,9 +208,9 @@ module PreSsa {
 
   predicate adjacentReadPairSameVar(AssignableRead read1, AssignableRead read2) {
     exists(SsaInput::BasicBlock bb1, int i1, SsaInput::BasicBlock bb2, int i2 |
-      read1 = bb1.getElement(i1) and
+      read1 = bb1.getNode(i1) and
       SsaImpl::adjacentUseUse(bb1, i1, bb2, i2, _, true) and
-      read2 = bb2.getElement(i2)
+      read2 = bb2.getNode(i2)
     )
   }
 }
diff --git a/csharp/ql/lib/semmle/code/csharp/dataflow/internal/BaseSSA.qll b/csharp/ql/lib/semmle/code/csharp/dataflow/internal/BaseSSA.qll
@@ -49,12 +49,6 @@ module BaseSsa {
 
     class ControlFlowNode = ControlFlow::Node;
 
-    BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) {
-      result = bb.getImmediateDominator()
-    }
-
-    BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
-
     class SourceVariable = PreSsa::SimpleLocalScopeVariable;
 
     predicate variableWrite(BasicBlock bb, int i, SourceVariable v, boolean certain) {
diff --git a/csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll b/csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll
@@ -283,15 +283,15 @@ module VariableCapture {
 
     class BasicBlock extends BasicBlocks::BasicBlock {
       Callable getEnclosingCallable() { result = super.getCallable() }
-    }
 
-    class ControlFlowNode = Cfg::ControlFlow::Node;
+      BasicBlock getASuccessor() { result = super.getASuccessor() }
 
-    BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) {
-      result = bb.getImmediateDominator()
+      BasicBlock getImmediateDominator() { result = super.getImmediateDominator() }
+
+      predicate inDominanceFrontier(BasicBlock df) { super.inDominanceFrontier(df) }
     }
 
-    BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
+    class ControlFlowNode = Cfg::ControlFlow::Node;
 
     private predicate thisAccess(ControlFlow::Node cfn, InstanceCallable c) {
       ThisFlow::thisAccessExpr(cfn.getAstNode()) and
diff --git a/csharp/ql/lib/semmle/code/csharp/dataflow/internal/SsaImpl.qll b/csharp/ql/lib/semmle/code/csharp/dataflow/internal/SsaImpl.qll
@@ -13,10 +13,6 @@ private module SsaInput implements SsaImplCommon::InputSig<Location> {
 
   class ControlFlowNode = ControlFlow::Node;
 
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result = bb.getImmediateDominator() }
-
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
-
   class SourceVariable = Ssa::SourceVariable;
 
   /**
diff --git a/java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll b/java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll
@@ -98,6 +98,12 @@ class BasicBlock extends BbImpl::BasicBlock {
   /** 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() { result = super.getASuccessor() }
+
+  BasicBlock getImmediateDominator() { result = super.getImmediateDominator() }
+
+  predicate inDominanceFrontier(BasicBlock df) { super.inDominanceFrontier(df) }
+
   /**
    * DEPRECATED: Use `getASuccessor` instead.
    *
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/BaseSSA.qll b/java/ql/lib/semmle/code/java/dataflow/internal/BaseSSA.qll
@@ -164,10 +164,6 @@ private module SsaInput implements SsaImplCommon::InputSig<Location> {
 
   class ControlFlowNode = J::ControlFlowNode;
 
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result.immediatelyDominates(bb) }
-
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
-
   class SourceVariable = BaseSsaSourceVariable;
 
   /**
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/DataFlowPrivate.qll b/java/ql/lib/semmle/code/java/dataflow/internal/DataFlowPrivate.qll
@@ -82,15 +82,15 @@ private module CaptureInput implements VariableCapture::InputSig<Location> {
     Callable getEnclosingCallable() { result = super.getEnclosingCallable() }
 
     Location getLocation() { result = super.getLocation() }
-  }
 
-  class ControlFlowNode = J::ControlFlowNode;
+    BasicBlock getASuccessor() { result = super.getASuccessor() }
 
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) {
-    result.(J::BasicBlock).immediatelyDominates(bb)
+    BasicBlock getImmediateDominator() { result = super.getImmediateDominator() }
+
+    predicate inDominanceFrontier(BasicBlock df) { super.inDominanceFrontier(df) }
   }
 
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.(J::BasicBlock).getASuccessor() }
+  class ControlFlowNode = J::ControlFlowNode;
 
   //TODO: support capture of `this` in lambdas
   class CapturedVariable instanceof LocalScopeVariable {
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/SsaImpl.qll b/java/ql/lib/semmle/code/java/dataflow/internal/SsaImpl.qll
@@ -173,10 +173,6 @@ private module SsaInput implements SsaImplCommon::InputSig<Location> {
 
   class ControlFlowNode = J::ControlFlowNode;
 
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result.immediatelyDominates(bb) }
-
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
-
   class SourceVariable = SsaSourceVariable;
 
   /**
diff --git a/javascript/ql/lib/semmle/javascript/dataflow/internal/VariableCapture.qll b/javascript/ql/lib/semmle/javascript/dataflow/internal/VariableCapture.qll
@@ -108,8 +108,18 @@ module VariableCaptureConfig implements InputSig<js::Location> {
 
   class ControlFlowNode = js::ControlFlowNode;
 
-  class BasicBlock extends js::BasicBlock {
+  final private class JsBasicBlock = js::BasicBlock;
+
+  class BasicBlock extends JsBasicBlock {
     Callable getEnclosingCallable() { result = this.getContainer().getFunctionBoundary() }
+
+    BasicBlock getASuccessor() { result = super.getASuccessor() }
+
+    BasicBlock getImmediateDominator() { result = super.getImmediateDominator() }
+
+    predicate inDominanceFrontier(BasicBlock df) {
+      df.(js::ReachableJoinBlock).inDominanceFrontierOf(this)
+    }
   }
 
   class Callable extends js::StmtContainer {
@@ -235,10 +245,6 @@ module VariableCaptureConfig implements InputSig<js::Location> {
     }
   }
 
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
-
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result = bb.getImmediateDominator() }
-
   predicate entryBlock(BasicBlock bb) { bb instanceof js::EntryBasicBlock }
 }
 
diff --git a/javascript/ql/lib/semmle/javascript/dataflow/internal/sharedlib/Ssa.qll b/javascript/ql/lib/semmle/javascript/dataflow/internal/sharedlib/Ssa.qll
@@ -12,7 +12,17 @@ private import semmle.javascript.dataflow.internal.VariableOrThis
 module SsaConfig implements InputSig<js::Location> {
   class ControlFlowNode = js::ControlFlowNode;
 
-  class BasicBlock = js::BasicBlock;
+  final private class JsBasicBlock = js::BasicBlock;
+
+  class BasicBlock extends JsBasicBlock {
+    BasicBlock getASuccessor() { result = super.getASuccessor() }
+
+    BasicBlock getImmediateDominator() { result = super.getImmediateDominator() }
+
+    predicate inDominanceFrontier(BasicBlock df) {
+      df.(js::ReachableJoinBlock).inDominanceFrontierOf(this)
+    }
+  }
 
   class SourceVariable extends LocalVariableOrThis {
     SourceVariable() { not this.isCaptured() }
@@ -40,11 +50,6 @@ module SsaConfig implements InputSig<js::Location> {
     certain = true and
     bb.getNode(i).(ThisUse).getBindingContainer() = v.asThisContainer()
   }
-
-  predicate getImmediateBasicBlockDominator = BasicBlockInternal::immediateDominator/1;
-
-  pragma[inline]
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
 }
 
 import Make<js::Location, SsaConfig>
@@ -55,7 +60,7 @@ module SsaDataflowInput implements DataFlowIntegrationInputSig {
   class Expr extends js::ControlFlowNode {
     Expr() { this = any(SsaConfig::SourceVariable v).getAUse() }
 
-    predicate hasCfgNode(js::BasicBlock bb, int i) { this = bb.getNode(i) }
+    predicate hasCfgNode(SsaConfig::BasicBlock bb, int i) { this = bb.getNode(i) }
   }
 
   predicate ssaDefHasSource(WriteDefinition def) {
@@ -82,7 +87,9 @@ module SsaDataflowInput implements DataFlowIntegrationInputSig {
      * Holds if the evaluation of this guard to `branch` corresponds to the edge
      * from `bb1` to `bb2`.
      */
-    predicate hasValueBranchEdge(js::BasicBlock bb1, js::BasicBlock bb2, GuardValue branch) {
+    predicate hasValueBranchEdge(
+      SsaConfig::BasicBlock bb1, SsaConfig::BasicBlock bb2, GuardValue branch
+    ) {
       exists(js::ConditionGuardNode g |
         g.getTest() = this and
         bb1 = this.getBasicBlock() and
@@ -96,13 +103,15 @@ module SsaDataflowInput implements DataFlowIntegrationInputSig {
      * branch edge from `bb1` to `bb2`. That is, following the edge from
      * `bb1` to `bb2` implies that this guard evaluated to `branch`.
      */
-    predicate valueControlsBranchEdge(js::BasicBlock bb1, js::BasicBlock bb2, GuardValue branch) {
+    predicate valueControlsBranchEdge(
+      SsaConfig::BasicBlock bb1, SsaConfig::BasicBlock bb2, GuardValue branch
+    ) {
       this.hasValueBranchEdge(bb1, bb2, branch)
     }
   }
 
   pragma[inline]
-  predicate guardDirectlyControlsBlock(Guard guard, js::BasicBlock bb, GuardValue branch) {
+  predicate guardDirectlyControlsBlock(Guard guard, SsaConfig::BasicBlock bb, GuardValue branch) {
     exists(js::ConditionGuardNode g |
       g.getTest() = guard and
       g.dominates(bb) and
diff --git a/python/ql/lib/semmle/python/Flow.qll b/python/ql/lib/semmle/python/Flow.qll
@@ -1082,9 +1082,15 @@ class BasicBlock extends @py_flow_node {
    * Dominance frontier of a node x is the set of all nodes `other` such that `this` dominates a predecessor
    * of `other` but does not strictly dominate `other`
    */
-  pragma[noinline]
-  predicate dominanceFrontier(BasicBlock other) {
-    this.dominates(other.getAPredecessor()) and not this.strictlyDominates(other)
+  predicate dominanceFrontier(BasicBlock other) { this.inDominanceFrontier(other) }
+
+  predicate inDominanceFrontier(BasicBlock df) {
+    this = df.getAPredecessor() and not this = df.getImmediateDominator()
+    or
+    exists(BasicBlock prev | prev.inDominanceFrontier(df) |
+      this = prev.getImmediateDominator() and
+      not this = df.getImmediateDominator()
+    )
   }
 
   private ControlFlowNode firstNode() { result = this }
diff --git a/python/ql/lib/semmle/python/dataflow/new/internal/VariableCapture.qll b/python/ql/lib/semmle/python/dataflow/new/internal/VariableCapture.qll
@@ -23,7 +23,9 @@ private module CaptureInput implements Shared::InputSig<Location> {
     predicate isConstructor() { none() }
   }
 
-  class BasicBlock extends PY::BasicBlock {
+  final private class PyBasicBlock = PY::BasicBlock;
+
+  class BasicBlock extends PyBasicBlock {
     int length() { result = count(int i | exists(this.getNode(i))) }
 
     Callable getEnclosingCallable() { result = this.getScope() }
@@ -34,13 +36,15 @@ private module CaptureInput implements Shared::InputSig<Location> {
     // and we just need a way to identify the basic block
     // during debugging, so this will be serviceable.
     Location getLocation() { result = super.getNode(0).getLocation() }
-  }
 
-  class ControlFlowNode = PY::ControlFlowNode;
+    BasicBlock getASuccessor() { result = super.getASuccessor() }
 
-  BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result = bb.getImmediateDominator() }
+    BasicBlock getImmediateDominator() { result = super.getImmediateDominator() }
 
-  BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }
+    predicate inDominanceFrontier(BasicBlock df) { super.inDominanceFrontier(df) }
+  }
+
+  class ControlFlowNode = PY::ControlFlowNode;
 
   class CapturedVariable extends LocalVariable {
     Function f;
diff --git a/ruby/ql/lib/codeql/ruby/dataflow/internal/DataFlowPrivate.qll b/ruby/ql/lib/codeql/ruby/dataflow/internal/DataFlowPrivate.qll
diff --git a/ruby/ql/lib/codeql/ruby/dataflow/internal/SsaImpl.qll b/ruby/ql/lib/codeql/ruby/dataflow/internal/SsaImpl.qll
diff --git a/rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll b/rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll
diff --git a/rust/ql/lib/codeql/rust/dataflow/internal/SsaImpl.qll b/rust/ql/lib/codeql/rust/dataflow/internal/SsaImpl.qll
diff --git a/shared/dataflow/codeql/dataflow/VariableCapture.qll b/shared/dataflow/codeql/dataflow/VariableCapture.qll
diff --git a/shared/ssa/codeql/ssa/Ssa.qll b/shared/ssa/codeql/ssa/Ssa.qll
diff --git a/swift/ql/lib/codeql/swift/dataflow/Ssa.qll b/swift/ql/lib/codeql/swift/dataflow/Ssa.qll
diff --git a/swift/ql/lib/codeql/swift/dataflow/internal/DataFlowPrivate.qll b/swift/ql/lib/codeql/swift/dataflow/internal/DataFlowPrivate.qll

Original file line number	Diff line number	Diff line change
`@@ -45,8 +45,8 @@ predicate bbIntraSuccInconsistency(ControlFlowElement pred, ControlFlowElement s`
`45`	`45`	`bb.getASuccessor().getFirstElement() = succ`
`46`	`46`	`) and`
`47`	`47`	`not exists(PreBasicBlock bb, int i \|`
`48`		`- bb.getElement(i) = pred and`
`49`		`- bb.getElement(i + 1) = succ`
	`48`	`+ bb.getNode(i) = pred and`
	`49`	`+ bb.getNode(i + 1) = succ`
`50`	`50`	`)`
`51`	`51`	`}`
`52`	`52`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,8 @@ final class BasicBlock extends BasicBlocksImpl::BasicBlock {`
`58`	`58`	`result.getFirstNode() = this.getLastNode().getAFalseSuccessor()`
`59`	`59`	`}`
`60`	`60`
	`61`	`+ BasicBlock getASuccessor() { result = super.getASuccessor() }`
	`62`	`+`
`61`	`63`	`/** Gets the control flow node at a specific (zero-indexed) position in this basic block. */`
`62`	`64`	`ControlFlow::Node getNode(int pos) { result = super.getNode(pos) }`
`63`	`65`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ module PreSsa {`
`14`	`14`	`private predicate definitionAt(`
`15`	`15`	`AssignableDefinition def, SsaInput::BasicBlock bb, int i, SsaInput::SourceVariable v`
`16`	`16`	`) {`
`17`		`- bb.getElement(i) = def.getExpr() and`
	`17`	`+ bb.getNode(i) = def.getExpr() and`
`18`	`18`	`v = def.getTarget() and`
`19`	`19`	// In cases like `(x, x) = (0, 1)`, we discard the first (dead) definition of `x`
`20`	`20`	`not exists(TupleAssignmentDefinition first, TupleAssignmentDefinition second \| first = def \|`
`@@ -80,16 +80,10 @@ module PreSsa {`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`module SsaInput implements SsaImplCommon::InputSig<Location> {`
`83`		`- class BasicBlock extends PreBasicBlocks::PreBasicBlock {`
`84`		`- ControlFlowNode getNode(int i) { result = this.getElement(i) }`
`85`		`- }`
	`83`	`+ class BasicBlock = PreBasicBlocks::PreBasicBlock;`
`86`	`84`
`87`	`85`	`class ControlFlowNode = ControlFlowElement;`
`88`	`86`
`89`		`- BasicBlock getImmediateBasicBlockDominator(BasicBlock bb) { result.immediatelyDominates(bb) }`
`90`		`-`
`91`		`- BasicBlock getABasicBlockSuccessor(BasicBlock bb) { result = bb.getASuccessor() }`
`92`		`-`
`93`	`87`	`private class ExitBasicBlock extends BasicBlock {`
`94`	`88`	`ExitBasicBlock() { scopeLast(_, this.getLastElement(), _) }`
`95`	`89`	`}`
`@@ -142,7 +136,7 @@ module PreSsa {`
`142`	`136`
`143`	`137`	`predicate variableRead(BasicBlock bb, int i, SourceVariable v, boolean certain) {`
`144`	`138`	`exists(AssignableRead read \|`
`145`		`- read = bb.getElement(i) and`
	`139`	`+ read = bb.getNode(i) and`
`146`	`140`	`read.getTarget() = v and`
`147`	`141`	`certain = true`
`148`	`142`	`)`
`@@ -163,7 +157,7 @@ module PreSsa {`
`163`	`157`	`final AssignableRead getARead() {`
`164`	`158`	`exists(SsaInput::BasicBlock bb, int i \|`
`165`	`159`	`SsaImpl::ssaDefReachesRead(_, this, bb, i) and`
`166`		`- result = bb.getElement(i)`
	`160`	`+ result = bb.getNode(i)`
`167`	`161`	`)`
`168`	`162`	`}`
`169`	`163`
`@@ -177,7 +171,7 @@ module PreSsa {`
`177`	`171`	`final AssignableRead getAFirstRead() {`
`178`	`172`	`exists(SsaInput::BasicBlock bb, int i \|`
`179`	`173`	`SsaImpl::firstUse(this, bb, i, true) and`
`180`		`- result = bb.getElement(i)`
	`174`	`+ result = bb.getNode(i)`
`181`	`175`	`)`
`182`	`176`	`}`
`183`	`177`
`@@ -214,9 +208,9 @@ module PreSsa {`
`214`	`208`
`215`	`209`	`predicate adjacentReadPairSameVar(AssignableRead read1, AssignableRead read2) {`
`216`	`210`	`exists(SsaInput::BasicBlock bb1, int i1, SsaInput::BasicBlock bb2, int i2 \|`
`217`		`- read1 = bb1.getElement(i1) and`
	`211`	`+ read1 = bb1.getNode(i1) and`
`218`	`212`	`SsaImpl::adjacentUseUse(bb1, i1, bb2, i2, _, true) and`
`219`		`- read2 = bb2.getElement(i2)`
	`213`	`+ read2 = bb2.getNode(i2)`
`220`	`214`	`)`
`221`	`215`	`}`
`222`	`216`	`}`