DeadCode: Create shared implementations for the cpp queries

Create shared implementations in preparation for the C queries.

Author: lcartey

cpp/autosar/src/rules/A0-1-4/UnusedParameter.ql

@@ -16,11 +16,8 @@
 import cpp
 import codingstandards.cpp.autosar
 import codingstandards.cpp.deadcode.UnusedParameters
+import codingstandards.cpp.rules.unusedparameter.UnusedParameter
 
-from Function f, UnusedParameter p
-where
-  not isExcluded(p, DeadCodePackage::unusedParameterQuery()) and
-  f = p.getFunction() and
-  // Virtual functions are covered by a different rule
-  not f.isVirtual()
-select p, "Unused parameter '" + p.getName() + "' for function $@.", f, f.getQualifiedName()
+class UnusedParameterQuery extends UnusedParameterSharedQuery {
+  UnusedParameterQuery() { this = DeadCodePackage::unusedParameterQuery() }
+}

cpp/autosar/src/rules/A0-1-6/UnusedTypeDeclarations.ql

@@ -16,13 +16,8 @@
 
 import cpp
 import codingstandards.cpp.autosar
-import codingstandards.cpp.TypeUses
+import codingstandards.cpp.rules.unusedtypedeclarations.UnusedTypeDeclarations
 
-from UserType ut
-where
-  not isExcluded(ut, DeadCodePackage::unusedTypeDeclarationsQuery()) and
-  not ut instanceof TemplateParameter and
-  not ut instanceof ProxyClass and
-  not exists(getATypeUse(ut)) and
-  not ut.isFromUninstantiatedTemplate(_)
-select ut, "Type declaration " + ut.getName() + " is not used."
+class UnusedTypeDeclarationsQuery extends UnusedTypeDeclarationsSharedQuery {
+  UnusedTypeDeclarationsQuery() { this = DeadCodePackage::unusedTypeDeclarationsQuery() }
+}

cpp/autosar/src/rules/M0-1-1/UnreachableCode.ql

@@ -17,39 +17,8 @@
 import cpp
 import codingstandards.cpp.autosar
 import codingstandards.cpp.deadcode.UnreachableCode
+import codingstandards.cpp.rules.unreachablecode.UnreachableCode
 
-/*
- * This query identifies unreachable code at the level of `BasicBlock`. We use `BasicBlock`s for
- * this because they represent sequences of statements which, according to the CFG, are either
- * all unreachable or all reachable, because control flow cannot escape from the middle of the
- * basic block.
- *
- * We use the `BasicBlock.isUnreachable()` predicate to identify `BasicBlock`s which are unreachable
- * according to our calculated control flow graph. In practice, this can resolve expressions used in
- * conditions which are constant, accesses of constant values (even across function boundaries), and
- * operations, recursively, on such expressions. There is no attempt made to resolve conditional
- * expressions which are not statically constant or derived directly from statically constant variables.
- *
- * One potential problem with using `BasicBlock`s is that for template functions the `BasicBlock` is
- * duplicated across multiple `Function` instances, one for uninstantiated templates, and one for
- * each instantiation. Rather than considering each template instantiation independently, we instead
- * only report a `BasicBlock` in a template as unreachable, if it is unreachable in all template
- * instantiations (and in the uninstantiated template). This helps avoid flagging examples such as
- * `return 1` as dead code in this example, where `T::isVal()` is statically deducible in some
- * template instantiations:
- * ```
- * template <class T> int f() {
- *   if (T::isVal()) return 1;
- *   return 2;
- * }
- * ```
- */
-
-from UnreachableBasicBlock b
-where
-  // None of the basic blocks are excluded
-  not isExcluded(b.getABasicBlock(), DeadCodePackage::unreachableCodeQuery()) and
-  // Exclude results where at least one of the basic blocks appears in a macro expansion, as
-  // macros can easily result in unreachable blocks through no fault of the user of the macro
-  not inMacroExpansion(b.getABasicBlock())
-select b, "This statement in function $@ is unreachable.", b.getPrimaryFunction() as f, f.getName()
+class UnreachableCodeQuery extends UnreachableCodeSharedQuery {
+  UnreachableCodeQuery() { this = DeadCodePackage::unreachableCodeQuery() }
+}

cpp/autosar/src/rules/M0-1-9/DeadCode.ql

@@ -16,116 +16,8 @@
 
 import cpp
 import codingstandards.cpp.autosar
-import codingstandards.cpp.deadcode.UselessAssignments
-import codingstandards.cpp.deadcode.UnreachableCode
+import codingstandards.cpp.rules.deadcode.DeadCode
 
-/*
- * This query finds the following kinds of dead code statement:
- * - A declaration of a non-static stack variable whose initializing expression is pure and that is never subsequently accessed in live code.
- * - A block that contain only dead statements.
- * - A do loop whose condition is pure, and whose body contains only dead statements.
- * - An if statement whose condition is pure, and whose then and else clauses (where they exist) only contain dead statements.
- * - A label statement to which the code never jumps.
- * - A while loop 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.
- */
-
-/**
- * Holds if the `Stmt` `s` is either dead or unreachable.
- */
-predicate isDeadOrUnreachableStmt(Stmt s) {
-  isDeadStmt(s)
-  or
-  s.getBasicBlock() = any(UnreachableBasicBlock ubb).getABasicBlock()
+class MisraCppDeadCodeQuery extends DeadCodeSharedQuery {
+  MisraCppDeadCodeQuery() { this = DeadCodePackage::deadCodeQuery() }
 }
-
-/**
- * Holds if the `Stmt` `s` is dead, i.e. could be executed, but its removal would not meaningfully
- * affect the program.
- */
-predicate isDeadStmt(Stmt s) {
-  // A `DeclStmt` is dead code if:
-  // - All the declarations are variable declarations
-  // - None of those variables are ever accessed in non-dead code
-  // - The initializers for each of the variables are pure
-  exists(DeclStmt ds |
-    ds = s and
-    // Use forex so that we don't flag "fake" generated `DeclStmt`s (e.g. those generated by the
-    // extractor for static_asserts) with no actual declarations
-    forex(Declaration d | d = ds.getADeclaration() |
-      exists(LocalScopeVariable v |
-        d = v and
-        v.getInitializer().getExpr().isPure() and
-        not exists(VariableAccess va |
-          va.getTarget() = v and
-          not isDeadOrUnreachableStmt(va.getEnclosingStmt())
-        )
-      )
-    )
-  )
-  or
-  // A block that only contains dead statements.
-  exists(BlockStmt b |
-    b = s and
-    forall(Stmt child | child = b.getAStmt() | isDeadStmt(child)) and
-    // If this is a catch block, we should only report it as dead if it is the last catch block.
-    not exists(TryStmt ts, int i |
-      ts.getCatchClause(i) = b and
-      i < (ts.getNumberOfCatchClauses() - 1)
-    )
-  )
-  or
-  // A do statement whose condition is pure, and whose body contains only dead statements.
-  exists(DoStmt ds |
-    ds = s and
-    ds.getCondition().isPure() and
-    isDeadOrUnreachableStmt(ds.getStmt())
-  )
-  or
-  // An if statement whose condition is pure, and whose then and else clauses (where they exist) are dead or unreachable
-  exists(IfStmt is |
-    is = s and
-    is.getCondition().isPure() and
-    // Then part is either dead or unreachable
-    isDeadOrUnreachableStmt(is.getThen()) and
-    (exists(is.getElse()) implies isDeadOrUnreachableStmt(is.getElse()))
-  )
-  or
-  // A while statement whose condition is pure, and whose body is a dead or unreachable statement
-  exists(WhileStmt ws |
-    ws = s and
-    ws.getCondition().isPure() and
-    isDeadOrUnreachableStmt(ws.getStmt())
-  )
-  or
-  // An expression statement which is pure
-  s.(ExprStmt).getExpr().isPure()
-  or
-  exists(SsaDefinition sd, LocalScopeVariable v |
-    // A useless definition
-    isUselessSsaDefinition(sd, v) and
-    s.(ExprStmt).getExpr() = sd.getDefinition() and
-    // The defining value is pure
-    sd.getDefiningValue(v).isPure()
-  )
-  or
-  // Any TryStmt with a dead body is dead. We ignore the catch blocks, because if the body is dead,
-  // no exception can be thrown, and so the catch blocks are unreachable
-  exists(TryStmt ts | s = ts and isDeadStmt(ts.getStmt()))
-}
-
-from Stmt s
-where
-  not isExcluded(s, DeadCodePackage::deadCodeQuery()) and
-  isDeadStmt(s) and
-  // Report only the highest level dead statement, to avoid over reporting
-  not isDeadStmt(s.getParentStmt()) and
-  // MISRA defines dead code as an "_executed_ statement whose removal would not affect the program
-  // output". We therefore exclude unreachable statements as they are, by definition, not executed.
-  not s.getBasicBlock() = any(UnreachableBasicBlock ubb).getABasicBlock() and
-  // Exclude code generated by macros, because the code may be "live" in other instantiations
-  not s.isAffectedByMacro() and
-  // Exclude compiler generated statements
-  not s.isCompilerGenerated()
-select s, "This statement is dead code."

cpp/autosar/test/rules/A0-1-4/UnusedParameter.qlref

@@ -0,0 +1 @@
+cpp/common/test/rules/unusedparameter/UnusedParameter.ql

cpp/autosar/test/rules/A0-1-4/UnusedParameter.testref

@@ -0,0 +1 @@
+cpp/common/test/rules/unusedtypedeclarations/UnusedTypeDeclarations.ql

cpp/autosar/test/rules/A0-1-6/UnusedTypeDeclarations.qlref

@@ -0,0 +1 @@
+cpp/common/test/rules/unreachablecode/UnreachableCode.ql