Fix more compilation errors in tests

Author: owen-mc

java/ql/consistency-queries/cfgDeadEnds.ql

@@ -1,6 +1,5 @@
 import java
 
-// import semmle.code.java.ControlFlowGraph
 predicate shouldBeDeadEnd(ExprParent n) {
   n instanceof BreakStmt and n.getFile().isKotlinSourceFile() // TODO
   or

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

@@ -66,3 +66,7 @@ class BasicBlock extends ControlFlowNode {
   /** Holds if this basic block post-dominates `node`. (This is reflexive.) */
   predicate bbPostDominates(BasicBlock node) { bbPostDominates(this, node) }
 }
+
+class ExitBlock extends BasicBlock {
+  ExitBlock() { this.getLastNode() instanceof ControlFlow::ExitNode }
+}

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

@@ -43,10 +43,6 @@ private predicate callAlwaysPerformsAction(Call call, ActionConfiguration conf)
   )
 }
 
-private class ExitBlock extends BasicBlock {
-  ExitBlock() { this.getLastNode() instanceof ControlFlow::ExitNode }
-}
-
 /** Holds if an action dominates the exit of the callable. */
 private predicate actionDominatesExit(Callable callable, ActionConfiguration conf) {
   exists(ExitBlock exit |

java/ql/lib/semmle/code/java/security/PathSanitizer.qll

@@ -29,15 +29,19 @@ private module ValidationMethod<DataFlow::guardChecksSig/3 validationGuard> {
    */
   private predicate validationMethod(Method m, int arg) {
     exists(
-      Guard g, SsaImplicitInit var, ControlFlowNode exit, ControlFlowNode normexit, boolean branch
+      Guard g, SsaImplicitInit var, ControlFlow::ExitNode exit, ControlFlowNode normexit,
+      boolean branch
     |
       validationGuard(g, var.getAUse(), branch) and
       var.isParameterDefinition(m.getParameter(arg)) and
-      exit = m and
+      exit.getEnclosingCallable() = m and
       normexit.getANormalSuccessor() = exit and
       1 = strictcount(ControlFlowNode n | n.getANormalSuccessor() = exit)
     |
-      g.(ConditionNode).getABranchSuccessor(branch) = exit or
+      exists(ConditionNode conditionNode |
+        g = conditionNode.getCondition() and conditionNode.getABranchSuccessor(branch) = exit
+      )
+      or
       g.controls(normexit.getBasicBlock(), branch)
     )
   }

java/ql/src/Likely Bugs/Comparison/UselessComparisonTest.qll

@@ -30,7 +30,7 @@ predicate uselessTest(ConditionNode s1, BinaryExpr test, boolean testIsTrue) {
     ConditionBlock cb, SsaVariable v, BinaryExpr cond, boolean condIsTrue, int k1, int k2,
     CompileTimeConstantExpr c1, CompileTimeConstantExpr c2
   |
-    s1 = cond and
+    s1.getCondition() = cond and
     cb.getCondition() = cond and
     cond.hasOperands(v.getAUse(), c1) and
     c1.getIntValue() = k1 and

java/ql/src/Likely Bugs/Concurrency/DoubleCheckedLockingWithInitRace.ql

@@ -36,7 +36,7 @@ where
   doubleCheckedLocking(if1, if2, sync, f) and
   a.getEnclosingStmt().getEnclosingStmt*() = if2.getThen() and
   se.getEnclosingStmt().getEnclosingStmt*() = sync.getBlock() and
-  a.(ControlFlowNode).getASuccessor+() = se and
+  a.getControlFlowNode().getASuccessor+().asExpr() = se and
   a.getDest().(FieldAccess).getField() = f
 select a,
   "Potential race condition. This assignment to $@ is visible to other threads before the subsequent statements are executed.",

java/ql/src/Likely Bugs/Concurrency/LazyInitStaticField.ql

@@ -64,12 +64,12 @@ class ValidSynchStmt extends Stmt {
       exists(MethodCall lockAction |
         lockAction.getQualifier() = lockField.getAnAccess() and
         lockAction.getMethod().getName() = "lock" and
-        dominates(lockAction, this)
+        dominates(lockAction.getControlFlowNode(), this.getControlFlowNode())
       ) and
       exists(MethodCall unlockAction |
         unlockAction.getQualifier() = lockField.getAnAccess() and
         unlockAction.getMethod().getName() = "unlock" and
-        postDominates(unlockAction, this)
+        postDominates(unlockAction.getControlFlowNode(), this.getControlFlowNode())
       )
     )
   }

java/ql/src/Likely Bugs/Concurrency/UnreleasedLock.ql

@@ -59,11 +59,11 @@ class LockType extends RefType {
 }
 
 predicate lockBlock(LockType t, BasicBlock b, int locks) {
-  locks = strictcount(int i | b.getNode(i) = t.getLockAccess())
+  locks = strictcount(int i | b.getNode(i).asExpr() = t.getLockAccess())
 }
 
 predicate unlockBlock(LockType t, BasicBlock b, int unlocks) {
-  unlocks = strictcount(int i | b.getNode(i) = t.getUnlockAccess())
+  unlocks = strictcount(int i | b.getNode(i).asExpr() = t.getUnlockAccess())
 }
 
 /**
@@ -90,11 +90,11 @@ predicate failedLock(LockType t, BasicBlock lockblock, BasicBlock exblock) {
   exists(ControlFlowNode lock |
     lock = lockblock.getLastNode() and
     (
-      lock = t.getLockAccess()
+      lock.asExpr() = t.getLockAccess()
       or
       exists(SsaExplicitUpdate lockbool |
         // Using the value of `t.getLockAccess()` ensures that it is a `tryLock` call.
-        lock = lockbool.getAUse() and
+        lock.asExpr() = lockbool.getAUse() and
         lockbool.getDefiningExpr().(VariableAssign).getSource() = t.getLockAccess()
       )
     ) and
@@ -147,12 +147,12 @@ predicate blockIsLocked(LockType t, BasicBlock src, BasicBlock b, int locks) {
   )
 }
 
-from Callable c, LockType t, BasicBlock src, BasicBlock exit, MethodCall lock
+from Callable c, LockType t, BasicBlock src, ExitBlock exit, MethodCall lock
 where
   // Restrict results to those methods that actually attempt to unlock.
   t.getUnlockAccess().getEnclosingCallable() = c and
   blockIsLocked(t, src, exit, _) and
-  exit.getLastNode() = c and
-  lock = src.getANode() and
+  exit.getEnclosingCallable() = c and
+  lock = src.getANode().asExpr() and
   lock = t.getLockAccess()
 select lock, "This lock might not be unlocked or might be locked more times than it is unlocked."

java/ql/src/Likely Bugs/Termination/ConstantLoopCondition.ql

@@ -61,7 +61,7 @@ predicate mainLoopCondition(LoopStmt loop, Expr cond) {
     else loopReentry = cond
   |
     last.getEnclosingStmt().getEnclosingStmt*() = loop.getBody() and
-    last.getASuccessor().(Expr).getParent*() = loopReentry
+    last.getASuccessor().asExpr().getParent*() = loopReentry
   )
 }
 
@@ -75,7 +75,7 @@ where
   // None of the ssa variables in `cond` are updated inside the loop.
   forex(SsaVariable ssa, VarRead use | ssa.getAUse() = use and use.getParent*() = cond |
     not ssa.getCfgNode().getEnclosingStmt().getEnclosingStmt*() = loop or
-    ssa.getCfgNode().(Expr).getParent*() = loop.(ForStmt).getAnInit()
+    ssa.getCfgNode().asExpr().getParent*() = loop.(ForStmt).getAnInit()
   ) and
   // And `cond` does not use method calls, field reads, or array reads.
   not exists(MethodCall ma | ma.getParent*() = cond) and

java/ql/src/Security/CWE/CWE-833/LockOrderInconsistency.ql

@@ -80,8 +80,8 @@ predicate badReentrantLockOrder(MethodCall first, MethodCall second, MethodCall
     otherSecond = v1.getLockAction() and
     second = v2.getLockAction() and
     otherFirst = v2.getLockAction() and
-    first.(ControlFlowNode).getASuccessor+() = second and
-    otherFirst.(ControlFlowNode).getASuccessor+() = otherSecond
+    first.getControlFlowNode().getASuccessor+() = second.getControlFlowNode() and
+    otherFirst.getControlFlowNode().getASuccessor+() = otherSecond.getControlFlowNode()
   |
     v1 != v2
   )