Fixes issue no. 121

Author: rak3-sh

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

@@ -0,0 +1 @@
+ - Considered use cases mentioned on issue [121](https://github.com/github/codeql-coding-standards/issues/121) while reporting a local function as "unused".

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

@@ -19,6 +19,44 @@ import codingstandards.cpp.autosar
 import codingstandards.cpp.DynamicCallGraph
 import codingstandards.cpp.deadcode.UnusedFunctions
 
+/** Checks if a function call exists to the function
+ * passed in the arguments.
+ */
+predicate isCalled(Function unusedFunction) {
+  exists (FunctionCall f | unusedFunction.getACallToThisFunction() = f)
+}
+
+/** 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 isCalled(f))
+  or
+  unusedFunction.getNamespace().isAnonymous() and
+    exists (TopLevelFunction overloadedFunction |
+      overloadedFunction != unusedFunction and
+      ((overloadedFunction.getName() = unusedFunction.getName()) or
+        (overloadedFunction.getQualifiedName() =
+          unusedFunction.getQualifiedName()))
+      )
+}
+
+/** Checks if a Function is part of an unevaluated context. */
+predicate partOfUnevalutedContexts(Function unusedFunction) {
+  exists (Expr e, FunctionCall f | ((e instanceof TypeidOperator or
+    e instanceof SizeofOperator or
+    e instanceof NoExceptExpr) and
+    e.getAChild*() = f and f.getTarget() = unusedFunction
+    )
+  )
+}
+
+/** 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 +113,22 @@ 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
+    not partOfUnevalutedContexts(unusedLocalFunction)
+  )
+  and
   // Get a printable name
   (
     if exists(unusedLocalFunction.getQualifiedName())

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

@@ -85,4 +85,66 @@ 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) // COMPLAINT - overload1(int) is called.
+{
+  return c+d;
+}
+
+namespace
+{
+  float overload1(int c, float d) // COMPLAINT - 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) // COMPLAINT - overloadMember(int, int) is called.
+    {
+      return ++c;
+    }
+    int overloadMember(int c, int d) // COMPLAINT - called.
+    {
+      return c+d;
+    }
+};