Java: Rename Block -> BlockStmt

Author: jbj

change-notes/1.26/analysis-java.md

@@ -0,0 +1,21 @@
+# Improvements to Java analysis
+
+The following changes in version 1.26 affect Java analysis in all applications.
+
+## General improvements
+
+## New queries
+
+| **Query**                   | **Tags**  | **Purpose**                                                        |
+|-----------------------------|-----------|--------------------------------------------------------------------|
+
+
+## Changes to existing queries
+
+| **Query**                    | **Expected impact**    | **Change**                        |
+|------------------------------|------------------------|-----------------------------------|
+
+
+## Changes to libraries
+
+* The QL class `Block`, denoting the `{ ... }` statement, is renamed to `BlockStmt`.

java/ql/examples/snippets/emptyblock.ql

@@ -9,6 +9,6 @@
 
 import java
 
-from Block blk
+from BlockStmt blk
 where blk.getNumStmt() = 0
 select blk

java/ql/examples/snippets/emptythen.ql

@@ -13,5 +13,5 @@
 import java
 
 from IfStmt i
-where i.getThen().(Block).getNumStmt() = 0
+where i.getThen().(BlockStmt).getNumStmt() = 0
 select i

java/ql/examples/snippets/singletonblock.ql

@@ -8,6 +8,6 @@
 
 import java
 
-from Block b
+from BlockStmt b
 where b.getNumStmt() = 1
 select b

java/ql/src/Advisory/Statements/OneStatementPerLine.ql

@@ -27,7 +27,7 @@ predicate oneLineStatement(Stmt s, File f, int line, int col) {
     col = l.getStartColumn()
   ) and
   // Exclude blocks: `{break;}` is not really a violation.
-  not s instanceof Block and
+  not s instanceof BlockStmt and
   // Exclude implicit super constructor invocations.
   not s instanceof SuperConstructorInvocationStmt and
   // Java enums are desugared to a whole bunch of generated statements.

java/ql/src/Complexity/BlockWithTooManyStatements.ql

@@ -20,6 +20,6 @@ class ComplexStmt extends Stmt {
   }
 }
 
-from Block b, int n
+from BlockStmt b, int n
 where n = count(ComplexStmt s | s = b.getAStmt()) and n > 3
 select b, "Block with too many statements (" + n.toString() + " complex statements in the block)."

java/ql/src/Frameworks/Spring/Architecture/Refactoring Opportunities/UnusedBean.ql

@@ -51,9 +51,9 @@ class ImpureStmt extends Stmt {
 /**
  * Get any non-block stmt in the block, including those nested within blocks.
  */
-private Stmt getANestedStmt(Block block) {
+private Stmt getANestedStmt(BlockStmt block) {
   // Any non-block statement
-  not result instanceof Block and result = block.getAStmt()
+  not result instanceof BlockStmt and result = block.getAStmt()
   or
   // Or any statement nested in a block
   result = getANestedStmt(block.getAStmt())

java/ql/src/Likely Bugs/Comparison/MissingInstanceofInEquals.ql

@@ -42,7 +42,7 @@ predicate hasTypeTest(Variable v) {
  */
 class ReferenceEquals extends EqualsMethod {
   ReferenceEquals() {
-    exists(Block b, ReturnStmt ret, EQExpr eq |
+    exists(BlockStmt b, ReturnStmt ret, EQExpr eq |
       this.getBody() = b and
       b.getStmt(0) = ret and
       ret.getResult() = eq and

java/ql/src/Likely Bugs/Statements/EmptyBlock.ql

@@ -13,7 +13,7 @@
 import semmle.code.java.Statement
 
 /** A block without statements or comments. */
-private Block emptyBlock() {
+private BlockStmt emptyBlock() {
   result.getNumStmt() = 0 and
   result.getLocation().getNumberOfCommentLines() = 0
 }
@@ -48,8 +48,8 @@ predicate blockParent(Stmt empty, string msg) {
     or
     empty.getParent() instanceof LoopStmt and msg = "The body of a loop should not be empty."
     or
-    empty.getParent() instanceof Block and
-    empty instanceof Block and
+    empty.getParent() instanceof BlockStmt and
+    empty instanceof BlockStmt and
     msg = "This block should not be empty."
   )
 }

java/ql/src/Likely Bugs/Statements/UseBraces.ql

@@ -15,11 +15,11 @@ import java
 
 /**
  * A control structure for which the trailing body (the syntactically last part)
- * is not a `Block`. This is either an `IfStmt` or a `LoopStmt`, but not a
+ * is not a `BlockStmt`. This is either an `IfStmt` or a `LoopStmt`, but not a
  * `DoStmt`, since do-while statements don't have a trailing body.
  */
 predicate unbracedTrailingBody(Stmt ctrlStructure, Stmt trailingBody) {
-  not trailingBody instanceof Block and
+  not trailingBody instanceof BlockStmt and
   (
     exists(IfStmt c | c = ctrlStructure |
       trailingBody = c.getElse() and not trailingBody instanceof IfStmt
@@ -33,15 +33,15 @@ predicate unbracedTrailingBody(Stmt ctrlStructure, Stmt trailingBody) {
 
 /*
  * The body of a `SwitchStmt` is a block, but it isn't represented explicitly
- * in the AST as a `Block`, so we have to take it into account directly in the
+ * in the AST as a `BlockStmt`, so we have to take it into account directly in the
  * following two predicates.
  */
 
 /**
- * Two consecutive statements in a `Block` statement or `SwitchStmt`.
+ * Two consecutive statements in a `BlockStmt` statement or `SwitchStmt`.
  */
 Stmt nextInBlock(Stmt s) {
-  exists(Block b, int i |
+  exists(BlockStmt b, int i |
     b.getStmt(i) = s and
     b.getStmt(i + 1) = result
   )
@@ -52,10 +52,10 @@ Stmt nextInBlock(Stmt s) {
   )
 }
 
-/** The `Stmt.getParent()` relation restricted to not pass through `Block`s or `SwitchStmt`s. */
+/** The `Stmt.getParent()` relation restricted to not pass through `BlockStmt`s or `SwitchStmt`s. */
 Stmt nonBlockParent(Stmt s) {
   result = s.getParent() and
-  not result instanceof Block and
+  not result instanceof BlockStmt and
   not result instanceof SwitchStmt
 }
 
@@ -64,7 +64,7 @@ predicate ifElseIf(IfStmt s, IfStmt elseif) { s.getElse() = elseif }
 
 /**
  * The statement `body` is an unbraced trailing body of a control structure and
- * `succ` is the next statement in the surrounding `Block` (or `SwitchStmt`).
+ * `succ` is the next statement in the surrounding `BlockStmt` (or `SwitchStmt`).
  */
 predicate shouldOutdent(
   Stmt ctrl, Stmt body, Stmt succ, int bodycol, int succcol, int bodyline, int succline
@@ -79,7 +79,7 @@ predicate shouldOutdent(
 
 /**
  * The statement `body` is an unbraced trailing body of a control structure and
- * `succ` is the next statement in the surrounding `Block` (or `SwitchStmt`).
+ * `succ` is the next statement in the surrounding `BlockStmt` (or `SwitchStmt`).
  * The indentation of statement `succ` is suspect because it is indented
  * the same way as `body` and thus visually suggests to be part of the same
  * syntactic scope as `body`.