Rule 2.2: Ignore results which are only dead in some compilations

Use the HoldsForAllInstances module to eliminate cases where a
line of code is compiled into multiple targets with different
dead code behaviour.

Author: lcartey

c/misra/src/rules/RULE-2-2/DeadCode.ql

@@ -36,10 +36,10 @@ class ExprStmtExpr extends Expr {
  * An "operation" as defined by MISRA C Rule 2.2 that is dead, i.e. it's removal has no effect on
  * the behaviour of the program.
  */
-class DeadOperation extends Expr {
+class DeadOperationInstance extends Expr {
   string description;
 
-  DeadOperation() {
+  DeadOperationInstance() {
     // Exclude cases nested within macro expansions, because the code may be "live" in other
     // expansions
     isNotWithinMacroExpansion(this) and
@@ -74,6 +74,8 @@ class DeadOperation extends Expr {
   string getDescription() { result = description }
 }
 
+class DeadOperation = HoldsForAllInstances<DeadOperationInstance, Expr>::LogicalResultElement;
+
 from DeadOperation deadOperation
-where not isExcluded(deadOperation, DeadCodePackage::deadCodeQuery())
-select deadOperation, deadOperation.getDescription() + "."
+where not isExcluded(deadOperation.getAnElementInstance(), DeadCodePackage::deadCodeQuery())
+select deadOperation, deadOperation.getAnElementInstance().getDescription() + "."

cpp/common/src/codingstandards/cpp/alertreporting/HoldsForAllInstances.qll

@@ -2,26 +2,26 @@
  * A module for considering whether a result occurs in all instances (e.g. copies) of the code at a
  * given location.
  *
- * Multiple instances of a statement at the same location can occur for two main reasons:
+ * Multiple instances of an element at the same location can occur for two main reasons:
  *  1. Instantiations of a template
  *  2. Re-compilation of a file under a different context
  * This module helps ensure that a particular condition holds for all copies of a particular logical
- * statement. For example, this can be used to determine whether a line of code is dead in all copies
+ * element. For example, this can be used to determine whether a line of code is dead in all copies
  * of a piece of code.
  *
- * This module is parameterized by a set of _candidate_ statements in the program. For each candidate
- * statement, we determine whether all other statements that occur at the same location in the
- * program are also part of the same set, ignoring any results generated by macros.
+ * This module is parameterized by a set of _candidate_ elements in the program. For each candidate
+ * element, we determine whether all other elements in the same element set that occur at the same
+ * location in the program are also part of the same set, ignoring any results generated by macros.
  *
- * We do so by reporting a new type of result, `LogicalResultStmt`, which represents a logical result
- * where all instances of a statement at a given location are considered to be part of the same set.
+ * We do so by reporting a new type of result, `LogicalResultElement`, which represents a logical result
+ * where all instances of a element at a given location are considered to be part of the same set.
  */
 
 import cpp
 
 /**
  * Holds if the `Element` `e` is not within a macro expansion, i.e. generated by a macro, but not
- * the outermost `Stmt` or `Expr` generated by the macro.
+ * the outermost `Element` or `Expr` generated by the macro.
  */
 predicate isNotWithinMacroExpansion(Element e) {
   not e.isInMacroExpansion()
@@ -37,32 +37,35 @@ predicate isNotWithinMacroExpansion(Element e) {
   )
 }
 
-/** A candidate set of types. */
-signature class CandidateStmtSig extends Stmt;
+/** A candidate set of elements. */
+signature class CandidateElementSig extends Element;
+
+/** The super set of relevant elements. */
+signature class ElementSetSig extends Element;
 
 /**
  * A module for considering whether a result occurs in all instances (e.g. copies) of the code at a
  * given location.
  */
-module HoldsForAllInstances<CandidateStmtSig CandidateStmt> {
+module HoldsForAllInstances<CandidateElementSig CandidateElement, ElementSetSig ElementSet> {
   private predicate hasLocation(
-    Stmt s, string filepath, int startline, int startcolumn, int endline, int endcolumn
+    ElementSet s, string filepath, int startline, int startcolumn, int endline, int endcolumn
   ) {
     s.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn)
   }
 
-  final private class MyStmt = Stmt;
+  final private class MyElement = ElementSet;
 
   /**
-   * A `Stmt` that appears at the same location as a candidate statement.
+   * A `Element` that appears at the same location as a candidate element.
    */
-  private class RelevantStmt extends MyStmt {
-    CandidateStmt s;
+  private class RelevantElement extends MyElement {
+    CandidateElement e;
 
-    RelevantStmt() {
+    RelevantElement() {
       exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
         hasLocation(this, filepath, startline, startcolumn, endline, endcolumn) and
-        hasLocation(s, filepath, startline, startcolumn, endline, endcolumn)
+        hasLocation(e, filepath, startline, startcolumn, endline, endcolumn)
       ) and
       // Not within a macro expansion, as we cannot match up instances by location in that
       // case
@@ -71,41 +74,43 @@ module HoldsForAllInstances<CandidateStmtSig CandidateStmt> {
       not this instanceof Handler
     }
 
-    CandidateStmt getCandidateStmt() { result = s }
+    CandidateElement getCandidateElement() { result = e }
   }
 
-  newtype TResultStmts =
-    TLogicalResultStmt(string filepath, int startline, int startcolumn, int endline, int endcolumn) {
-      exists(CandidateStmt s |
+  newtype TResultElements =
+    TLogicalResultElement(
+      string filepath, int startline, int startcolumn, int endline, int endcolumn
+    ) {
+      exists(CandidateElement s |
         // Only consider candidates where we can match up the location
         isNotWithinMacroExpansion(s) and
         hasLocation(s, filepath, startline, startcolumn, endline, endcolumn) and
-        // All relevant statements that occur at the same location are candidates
-        forex(RelevantStmt relevantStmt | s = relevantStmt.getCandidateStmt() |
-          relevantStmt instanceof CandidateStmt
+        // All relevant elements that occur at the same location are candidates
+        forex(RelevantElement relevantElement | s = relevantElement.getCandidateElement() |
+          relevantElement instanceof CandidateElement
         )
       )
     }
 
   /**
-   * A logical result statement, representing all instances of a statement that occur at the same
+   * A logical result element, representing all instances of a element that occur at the same
    * location.
    */
-  class LogicalResultStmt extends TLogicalResultStmt {
+  class LogicalResultElement extends TLogicalResultElement {
     predicate hasLocationInfo(
       string filepath, int startline, int startcolumn, int endline, int endcolumn
     ) {
-      this = TLogicalResultStmt(filepath, startline, startcolumn, endline, endcolumn)
+      this = TLogicalResultElement(filepath, startline, startcolumn, endline, endcolumn)
     }
 
-    /** Gets an instance of this logical result statement. */
-    CandidateStmt getAStmtInstance() {
+    /** Gets an instance of this logical result element. */
+    CandidateElement getAnElementInstance() {
       exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
-        this = TLogicalResultStmt(filepath, startline, startcolumn, endline, endcolumn) and
+        this = TLogicalResultElement(filepath, startline, startcolumn, endline, endcolumn) and
         hasLocation(result, filepath, startline, startcolumn, endline, endcolumn)
       )
     }
 
-    string toString() { result = getAStmtInstance().toString() }
+    string toString() { result = getAnElementInstance().toString() }
   }
 }

cpp/common/src/codingstandards/cpp/rules/deadcode/DeadCode.qll

@@ -122,16 +122,16 @@ class DeadStmtInstance extends Stmt {
   }
 }
 
-class DeadStmt = HoldsForAllInstances<DeadStmtInstance>::LogicalResultStmt;
+class DeadStmt = HoldsForAllInstances<DeadStmtInstance, Stmt>::LogicalResultElement;
 
 query predicate problems(DeadStmt s, string message) {
-  not isExcluded(s.getAStmtInstance(), getQuery()) and
+  not isExcluded(s.getAnElementInstance(), getQuery()) and
   message = "This statement is dead code." and
   // Report only the highest level dead statement, to avoid over reporting
   not exists(DeadStmt parent |
     // All instances must share a dead statement parent for us to report the parent instead
-    forall(Stmt instance | instance = s.getAStmtInstance() |
-      parent.getAStmtInstance() = instance.getParentStmt()
+    forall(Stmt instance | instance = s.getAnElementInstance() |
+      parent.getAnElementInstance() = instance.getParentStmt()
     )
   )
 }