JS: Refactor some internal methods to make them easier to alias

We need these to return the dominator instead of declaring it in the parameter list, so that we can use it directly to fulfill part of the signature for the SSA library.

We can't rewrite it with an inline predicate since the SSA module calls with a transitive closure '*', which does not permit inline predicates.

Author: asgerf

javascript/ql/lib/semmle/javascript/BasicBlocks.qll

@@ -102,15 +102,15 @@ private module Internal {
 
 private import Internal
 
-/** Holds if `dom` is an immediate dominator of `bb`. */
+/** Gets the immediate dominator of `bb`. */
 cached
-private predicate bbIDominates(BasicBlock dom, BasicBlock bb) =
-  idominance(entryBB/1, succBB/2)(_, dom, bb)
+private BasicBlock immediateDominator(BasicBlock bb) =
+  idominance(entryBB/1, succBB/2)(_, result, bb)
 
-/** Holds if `dom` is an immediate post-dominator of `bb`. */
+/** Gets the immediate post-dominator of `bb`. */
 cached
-private predicate bbIPostDominates(BasicBlock dom, BasicBlock bb) =
-  idominance(exitBB/1, predBB/2)(_, dom, bb)
+private BasicBlock immediatePostDominator(BasicBlock bb) =
+  idominance(exitBB/1, predBB/2)(_, result, bb)
 
 /**
  * A basic block, that is, a maximal straight-line sequence of control flow nodes
@@ -279,7 +279,7 @@ class BasicBlock extends @cfg_node, NodeInStmtContainer {
   /**
    * Gets the basic block that immediately dominates this basic block.
    */
-  ReachableBasicBlock getImmediateDominator() { bbIDominates(result, this) }
+  ReachableBasicBlock getImmediateDominator() { result = immediateDominator(this) }
 }
 
 /**
@@ -308,29 +308,29 @@ class ReachableBasicBlock extends BasicBlock {
    * Holds if this basic block strictly dominates `bb`.
    */
   pragma[inline]
-  predicate strictlyDominates(ReachableBasicBlock bb) { bbIDominates+(this, bb) }
+  predicate strictlyDominates(ReachableBasicBlock bb) { this = immediateDominator+(bb) }
 
   /**
    * Holds if this basic block dominates `bb`.
    *
    * This predicate is reflexive: each reachable basic block dominates itself.
    */
   pragma[inline]
-  predicate dominates(ReachableBasicBlock bb) { bbIDominates*(this, bb) }
+  predicate dominates(ReachableBasicBlock bb) { this = immediateDominator*(bb) }
 
   /**
    * Holds if this basic block strictly post-dominates `bb`.
    */
   pragma[inline]
-  predicate strictlyPostDominates(ReachableBasicBlock bb) { bbIPostDominates+(this, bb) }
+  predicate strictlyPostDominates(ReachableBasicBlock bb) { this = immediatePostDominator+(bb) }
 
   /**
    * Holds if this basic block post-dominates `bb`.
    *
    * This predicate is reflexive: each reachable basic block post-dominates itself.
    */
   pragma[inline]
-  predicate postDominates(ReachableBasicBlock bb) { bbIPostDominates*(this, bb) }
+  predicate postDominates(ReachableBasicBlock bb) { this = immediatePostDominator*(bb) }
 }
 
 /**