Sorting out false positives for A0-1-2 and A0-1-4

cpp/autosar/src/rules/A0-1-2/UnusedReturnValue.ql

@@ -18,6 +18,32 @@ import cpp
 import codingstandards.cpp.autosar
 import semmle.code.cpp.dataflow.DataFlow
 
+predicate isStdIgnore(Element element) {
+  exists(NameQualifier nq |
+    nq.getQualifiedElement().toString() = "ignore" and
+    nq.toString() = "std::" and
+    element.toString() = "ignore"
+  )
+}
+
+/* The statement std::ignore = f() is not recognized an assignment; therefore, we do some painful gymnastics. */
+predicate isAssignment(FunctionCall assignment) {
+  exists(Operator operator |
+    assignment.getTarget() = operator and
+    operator.getName() = "operator=" and
+    // check if this is indeed an operator for assignment by checking if there are no overloads
+    not exists(operator.getAnOverload())
+  )
+}
+
+predicate isAssignmentOperand(Expr operand) {
+  exists(FunctionCall assignment | isAssignment(assignment) and operand = assignment.getAChild())
+}
+
+predicate returnValueIsAssignedToStdIgnore(FunctionCall fc) {
+  isAssignmentOperand(fc) and exists(Element stdIgnore | isStdIgnore(stdIgnore))
+}
+
 /*
  * This query performs a simple syntactic check to ensure that the return value of the function is
  * not completely ignored. This matches the examples given in the rule, although the text itself is
@@ -39,8 +65,17 @@ where
   // so the rule does not require the use of the return value
   not f instanceof Operator and
   // Exclude cases where the function call is generated within a macro, as the user of the macro is
-  // not necessarily able to address thoes results
+  // not necessarily able to address those results
   not fc.isAffectedByMacro() and
-  // Rule allows disabling this rule where a static_cast<void> is applied
-  not fc.getExplicitlyConverted().(StaticCast).getActualType() instanceof VoidType
+  // Rule allows disabling this rule where a static_cast<void> or a C-style cast to void is applied
+  not (
+    fc.getExplicitlyConverted().(StaticCast).getActualType() instanceof VoidType
+    or
+    exists(CStyleCast cast |
+      not cast.isCompilerGenerated() and
+      cast.getExpr() = fc and
+      cast.getActualType() instanceof VoidType
+    )
+  ) and
+  not returnValueIsAssignedToStdIgnore(fc)
 select fc, "Return value from call to $@ is unused.", f, f.getName()

cpp/autosar/test/rules/A0-1-2/UnusedReturnValue.expected

@@ -1 +1 @@
-| test.cpp:10:3:10:3 | call to f | Return value from call to $@ is unused. | test.cpp:1:5:1:5 | f | f |
+| test.cpp:12:3:12:3 | call to f | Return value from call to $@ is unused. | test.cpp:3:5:3:5 | f | f |

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

@@ -1,3 +1,5 @@
+#include <tuple>
+
 int f();
 void g(int x);
 
@@ -8,7 +10,8 @@ class A {
 
 void test_return_val() {
   f();                    // NON_COMPLIANT - return value never read
-  static_cast<void>(f()); // COMPLIANT
+  static_cast<void>(f()); // COMPLIANT - explicitly ignoring the return value by
+                          // static_cast to void.
   int x = f(); // COMPLIANT - according to the rule, even though it's not in
                // practice used because the unused assignment would be flagged
                // by A0-1-1
@@ -17,4 +20,9 @@ void test_return_val() {
   A a2;
   a1 + a2; // COMPLIANT - `+` is a call to operator+, but is permitted by the
            // rule
-}
+
+  (void)f(); // COMPLIANT - explicitly ignoring the return value by C-style cast
+             // to void.
+  std::ignore = f(); // COMPLIANT - explicitly ignoring the return value by
+                     // assigning to std::ignore.
+}

cpp/common/src/codingstandards/cpp/deadcode/UnusedParameters.qll

@@ -1,40 +1,56 @@
 /**
- * A library for identifying parameters which may be unused.
- */
+* A library for identifying parameters which may be unused.
+*/
 
 import cpp
 
 /**
- * A `Parameter` which is "usable" within the function.
- *
- * For this to be the case, the `Function` must have a definition, and that definition must include
- * a body block, and the parameter must be a named parameter.
- */
+* A `Parameter` which is "usable" within the function.
+*
+* For this to be the case, the `Function` must have a definition, and that definition must include
+* a body block, and the parameter must be a named parameter.
+*/
 class UsableParameter extends Parameter {
   UsableParameter() {
-    // Find the function associated with the parameter
-    exists(Function f | this = f.getAParameter() |
-      // Must have the definition of the function, not just the declaration
-      f.hasDefinition() and
-      // There must be a body block associated with the function, otherwise the parameter cannot
-      // possibly be used
-      exists(f.getBlock())
-    ) and
+    (
+      /* Regular Function */
+      // Find the function associated with the parameter
+     exists(Function f | this = f.getAParameter() |
+        // Must have the definition of the function, not just the declaration
+       f.hasDefinition() and
+        // There must be a body block associated with the function, otherwise the parameter cannot
+        // possibly be used
+       exists(f.getBlock())
+     )
+     or
+      /* Lambda Expression */
+      // Find the function associated with the parameter
+     exists(LambdaExpression lambda, Function f |
+       this = lambda.getLambdaFunction().getParameter(_)
+       |
+        // Must have the definition of the function, not just the declaration
+       lambda.getLambdaFunction() = f and
+       f.hasDefinition() and
+        // There must be a body block associated with the function, otherwise the parameter cannot
+        // possibly be used
+       exists(f.getBlock())
+     )
+     ) and
     // Must be a named parameter, because unnamed parameters cannot be referenced
     isNamed()
   }
 }
 
 /**
- * A `Parameter` which is usable but not directly used in the local context.
- */
+* A `Parameter` which is usable but not directly used in the local context.
+*/
 class UnusedParameter extends UsableParameter {
   UnusedParameter() { not this instanceof UsedParameter }
 }
 
 /**
- * A `Parameter` which is used in the local context.
- */
+* A `Parameter` which is used in the local context.
+*/
 class UsedParameter extends UsableParameter {
   UsedParameter() {
     // An access to the parameter exists in the function body

cpp/common/src/codingstandards/cpp/rules/unusedparameter/UnusedParameter.qll

@@ -11,11 +11,34 @@ abstract class UnusedParameterSharedQuery extends Query { }
 
 Query getQuery() { result instanceof UnusedParameterSharedQuery }
 
+query predicate isMaybeUnusedParameter(Parameter parameter) {
+  parameter.getAnAttribute().toString() = "maybe_unused"
+}
+
+// query
+predicate isLambdaParameter(Parameter parameter) {
+  exists(LambdaExpression lambda | lambda.getLambdaFunction().getParameter(_) = parameter)
+}
+
+// query
+predicate isLambdaMaybeUnusedParameter(Parameter parameter) {
+  exists(LambdaExpression lambda | lambda.getLambdaFunction().getParameter(_) = parameter) and
+  isMaybeUnusedParameter(parameter)
+}
+
+query predicate lambdaExprParamHasAccess(Parameter parameter) {
+  exists(VariableAccess va | isLambdaParameter(parameter) and parameter.getAnAccess() = va)
+}
+
 query predicate problems(UnusedParameter p, string message, Function f, string fName) {
   not isExcluded(p, getQuery()) and
-  f = p.getFunction() and
-  // Virtual functions are covered by a different rule
-  not f.isVirtual() and
+  (
+    not isMaybeUnusedParameter(p) and
+    f = p.getFunction() and
+    // Virtual functions are covered by a different rule
+    not f.isVirtual()
+  ) and
   message = "Unused parameter '" + p.getName() + "' for function $@." and
-  fName = f.getQualifiedName()
+  // fName = f.getQualifiedName()
+  fName = "TODO."
 }

cpp/common/test/includes/standard-library/tuple.h

@@ -1,4 +1,12 @@
 namespace std {
 template <class... Types> class tuple {};
 template <class... Types> std::tuple<Types...> make_tuple(Types &&...args);
+// TODO change this to example from cpp standard
+struct ignore_t {
+  template <typename T>
+  constexpr // required since C++14
+      void
+      operator=(T &&) const noexcept {}
+};
+inline constexpr std::ignore_t ignore; // 'const' only until C++17
 } // namespace std

cpp/common/test/rules/unusedparameter/test.cpp

@@ -1,6 +1,8 @@
 // NOTICE: SOME OF THE TEST CASES BELOW ARE ALSO INCLUDED IN THE C TEST CASE AND
 // CHANGES SHOULD BE REFLECTED THERE AS WELL.
 
+#include <tuple>
+
 int test_used(int x) { return x; } // COMPLIANT
 
 void test_unused(int x) {} // NON_COMPLIANT
@@ -16,4 +18,29 @@ class A {
   virtual void d(int x, int y) {} // virtual, not covered by this rule
 };
 
-void test_no_def(int x); // COMPLIANT - no definition, so cannot be "unused"
+void f(
+    int i,			// COMPLIANT
+    int j,			// COMPLIANT
+    int k,			// COMPLIANT
+    [[maybe_unused]] int l // COMPLIANT: explicitly stated as [[maybe_unused]]
+) {
+  static_cast<void>(i); // COMPLIANT: explicitly ignored by static_cast to void
+  (void)j;              // COMPLIANT: explicitly ignored by c-style cast to void
+  std::ignore = k; // COMPLIANT: explicitly ignored by assignment to std::ignore
+}
+
+void test_lambda_expr() {
+  auto lambda =
+      [](int x, // COMPLIANT: used
+         int y, // NON_COMPLIANT: unused without explicit notice
+         [[maybe_unused]] int z, // COMPLIANT: stdattribute [[maybe_unused]]
+         int w,                  // COMPLIANT: static_cast to void
+         int u,                  // COMPLIANT: c-style cast to void
+         int) {                  // COMPLIANT: unnamed parameter
+        static_cast<void>(w);
+        (void)u;
+        return x;
+      };
+}
+
+void test_no_def(int x); // COMPLIANT - no definition, so cannot be "unused"