Consider additional use-cases to conclude a function as "used"

change_notes/2023-06-28-unused-local-function-use-cases.md

@@ -0,0 +1,6 @@
+- `A0-1-3` - Considered the following additional use cases while reporting a local function as "unused".
+  - The address of a function is taken
+  - The operand of an expression in an unevaluated context
+  - Functions marked with [[maybe_unused]]
+  - Explicitly deleted functions e.g. =delete
+  - Use of any overload of a function in an overload set constitute a use of all members of the set. An overload set is a set of functions with the same name that differ in the number, type and/or qualifiers of their parameters, and, for the purpose of this query, are limited to functions which are declared in the same scope (namespace or class).

cpp/autosar/src/rules/A0-1-3/UnusedLocalFunction.ql

@@ -19,6 +19,20 @@ import codingstandards.cpp.autosar
 import codingstandards.cpp.DynamicCallGraph
 import codingstandards.cpp.deadcode.UnusedFunctions
 
+
+/** Checks if an overloaded function of
+ * the function passed in the arguments, is called.
+ */
+predicate overloadedFunctionIsCalled(Function unusedFunction) {
+  exists (Function f | f = unusedFunction.getAnOverload() and f = getTarget(_))
+}
+
+/** Checks if a Function's address was taken. */
+predicate addressBeenTaken(Function unusedFunction)
+{
+  exists (FunctionAccess fa | fa.getTarget() = unusedFunction)
+}
+
 /** A `Function` nested in an anonymous namespace. */
 class AnonymousNamespaceFunction extends Function {
   AnonymousNamespaceFunction() { getNamespace().getParentNamespace*().isAnonymous() }
@@ -75,7 +89,19 @@ where
     // There exists an instantiation which is called
     functionFromInstantiatedTemplate.isConstructedFrom(functionFromUninstantiatedTemplate) and
     functionFromInstantiatedTemplate = getTarget(_)
-  ) and
+  )
+  and
+  // A function is defined as "used" if any one of the following holds true:
+  // - It's an explicitly deleted functions e.g. =delete
+  // - It's annotated as "[[maybe_unused]]"
+  // - It's part of an overloaded set and any one of the overloaded instance
+  //   is called.
+  // - It's an operand of an expression in an unevaluated context.
+  not unusedLocalFunction.isDeleted() and
+  not unusedLocalFunction.getAnAttribute().getName() = "maybe_unused" and
+  not overloadedFunctionIsCalled(unusedLocalFunction) and
+  not addressBeenTaken(unusedLocalFunction)
+  and
   // Get a printable name
   (
     if exists(unusedLocalFunction.getQualifiedName())

cpp/autosar/test/rules/A0-1-3/test.cpp

@@ -85,4 +85,55 @@ namespace bar {
 void h3() {} // NON_COMPLIANT
 } // namespace bar
 } // namespace foo
-} // namespace
+} // namespace
+
+static int unevaluatedContextFn(int x) {
+  x++;
+  return x;
+} // COMPLIANT - called in an unevaluated context.
+#include <typeinfo>
+static int unevalContextCaller() // COMPLIANT - address taken
+{
+
+  typeid(unevaluatedContextFn(0));
+  sizeof(unevaluatedContextFn(1));
+  noexcept(unevaluatedContextFn(2));
+  decltype(unevaluatedContextFn(2)) n = 42;
+  return 0;
+}
+int (*ptr_unevalContextCaller)(void) = unevalContextCaller;
+
+class X {
+private:
+  [[maybe_unused]] void maybeUnused();
+  void deleted() = delete; // COMPLIANT - Deleted Function
+};
+
+void X::maybeUnused() {} // COMPLIANT - [[maybe_unused]]
+
+static int overload1(int c) // COMPLIANT - called
+{
+  return ++c;
+}
+
+static int overload1(int c, int d) // COMPLIANT - overload1(int) is called.
+{
+  return c + d;
+}
+
+int overload = overload1(5);
+
+class classWithOverloads {
+public:
+  int caller(int x) { return overloadMember(x, 0); }
+
+private:
+  int overloadMember(int c) // COMPLIANT - overloadMember(int, int) is called.
+  {
+    return ++c;
+  }
+  int overloadMember(int c, int d) // COMPLIANT - called.
+  {
+    return c + d;
+  }
+};

rule_packages/cpp/DeadCode.json

@@ -67,7 +67,10 @@
           "tags": [
             "readability",
             "maintainability"
-          ]
+          ],
+          "implementation_scope": {
+            "description": "Use of any overload of a function in an overload set constitute a use of all members of the set. An overload set is a set of functions with the same name that differ in the number, type and/or qualifiers of their parameters, and, for the purpose of this query, are limited to functions which are declared in the same scope (namespace or class). Functions defined in anonymous (unnamed) namespaces and global namespaces are therefore not currently considered to be part of the same overload set."
+          }
         }
       ],
       "title": "Every function defined in an anonymous namespace, or static function with internal linkage, or private member function shall be used."