RULE-2-2: Refactor to detect dead operations

The rule description for this rule in fact talks about dead
operations, not dead statements. Therefore:
 - Unshare the rule from MISRA C++ 2008
 - Implement dead operation, as per the rule

Author: lcartey

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

@@ -14,8 +14,62 @@
 
 import cpp
 import codingstandards.c.misra
-import codingstandards.cpp.rules.deadcode.DeadCode
+import codingstandards.cpp.deadcode.UselessAssignments
 
-class MisraCDeadCodeQuery extends DeadCodeSharedQuery {
-  MisraCDeadCodeQuery() { this = DeadCodePackage::deadCodeQuery() }
+/**
+ * Gets an explicit cast from `e` if one exists.
+ */
+Cast getExplicitCast(Expr e) {
+  exists(Conversion c | c = e.getExplicitlyConverted() |
+    result = c
+    or
+    result = c.(ParenthesisExpr).getExpr()
+  )
+}
+
+class ExprStmtExpr extends Expr {
+  ExprStmtExpr() { exists(ExprStmt es | es.getExpr() = this) }
 }
+
+/**
+ * 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 {
+  string description;
+
+  DeadOperation() {
+    exists(ExprStmtExpr e |
+      if exists(getExplicitCast(e))
+      then
+        this = getExplicitCast(e) and
+        // void conversions are permitted
+        not getExplicitCast(e) instanceof VoidConversion and
+        description = "Cast operation is unused"
+      else (
+        this = e and
+        (
+          if e instanceof Assignment
+          then
+            exists(SsaDefinition sd, LocalScopeVariable v |
+              e = sd.getDefinition() and
+              sd.getDefiningValue(v).isPure() and
+              // The definition is useless
+              isUselessSsaDefinition(sd, v) and
+              description = "Assignment to " + v.getName() + " is unused and has no side effects"
+            )
+          else (
+            e.isPure() and
+            description = "Result of operation is unused and has no side effects"
+          )
+        )
+      )
+    )
+  }
+
+  string getDescription() { result = description }
+}
+
+from DeadOperation deadOperation
+where not isExcluded(deadOperation, DeadCodePackage::deadCodeQuery())
+select deadOperation, deadOperation.getDescription() + "."

c/misra/test/rules/RULE-2-2/DeadCode.expected

@@ -0,0 +1,7 @@
+| test.c:15:3:15:11 | ... = ... | Assignment to dead1 is unused and has no side effects. |
+| test.c:16:3:16:11 | ... = ... | Assignment to dead2 is unused and has no side effects. |
+| test.c:19:3:19:7 | ... + ... | Result of operation is unused and has no side effects. |
+| test.c:21:3:21:17 | call to no_side_effects | Result of operation is unused and has no side effects. |
+| test.c:23:3:23:30 | (int)... | Cast operation is unused. |
+| test.c:24:3:24:25 | (int)... | Cast operation is unused. |
+| test.c:27:4:27:18 | call to no_side_effects | Result of operation is unused and has no side effects. |

c/misra/test/rules/RULE-2-2/DeadCode.qlref

@@ -0,0 +1 @@
+rules/RULE-2-2/DeadCode.ql

c/misra/test/rules/RULE-2-2/DeadCode.testref

@@ -0,0 +1,30 @@
+int may_have_side_effects();
+int no_side_effects(int x) { return 1 + 2; }
+int no_side_effects_nondeterministic();
+
+int test_dead_code(int x) {
+  int live1 = may_have_side_effects(),
+      live2 = may_have_side_effects(); // COMPLIANT
+  int live3 = 0,
+      live4 = may_have_side_effects(); // COMPLIANT
+  int live5 = 0, live6 = 0;            // COMPLIANT
+  live5 = 1;                           // COMPLIANT
+  live6 = 2;                           // COMPLIANT
+
+  int dead1 = 0, dead2 = 0; // COMPLIANT - init not considered by this rule
+  dead1 = 1;                // NON_COMPLIANT - useless assignment
+  dead2 = 1;                // NON_COMPLIANT - useless assignment
+
+  may_have_side_effects(); // COMPLIANT
+  1 + 2;                   // NON_COMPLIANT
+
+  no_side_effects(x); // NON_COMPLIANT
+
+  (int)may_have_side_effects(); // NON_COMPLIANT
+  (int)no_side_effects(x);      // NON_COMPLIANT
+  (void)no_side_effects(x);     // COMPLIANT
+  (may_have_side_effects());    // COMPLIANT
+  (no_side_effects(x));         // NON_COMPLIANT
+
+  return live5 + live6; // COMPLIANT
+}

c/misra/test/rules/RULE-2-2/test.c

@@ -39,21 +39,7 @@
           "tags": [
             "readability",
             "maintainability"
-          ],
-          "implementation_scope": {
-            "description": "This query identifies dead statements in the program of the following kinds:",
-            "items": [
-              "Declarations of a non-static stack variable whose initializing expression is pure (i.e. has no side-effects) and that is never subsequently accessed in live code.",
-              "Blocks that contain only dead statements.",
-              "Do loops whose condition is pure, and whose body contains only dead statements.",
-              "If statements whose condition is pure, and whose then and else clauses (where they exist) only contain dead statements.",
-              "Label statements to which the code never jumps.",
-              "While loops whose condition is pure, and whose body contains only dead statements.",
-              "Expression statements whose expressions are pure.",
-              "Writes to a non-static stack variable that is never subsequently read in live code."
-            ]
-          },
-          "shared_implementation_short_name": "DeadCode"
+          ]
         }
       ],
       "title": "There shall be no dead code"