First draft of UnusedReturnValue

Author: jeongsoolee09

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

@@ -1,32 +1,48 @@
 /**
- * @id cpp/autosar/unused-return-value
- * @name A0-1-2: Unused return value
- * @description The value returned by a function having a non-void return type that is not an
- *              overloaded operator shall be used.
- * @kind problem
- * @precision very-high
- * @problem.severity warning
- * @tags external/autosar/id/a0-1-2
- *       readability
- *       maintainability
- *       external/autosar/allocated-target/implementation
- *       external/autosar/enforcement/automated
- *       external/autosar/obligation/required
- */
+* @id cpp/autosar/unused-return-value
+* @name A0-1-2: Unused return value
+* @description The value returned by a function having a non-void return type that is not an
+*              overloaded operator shall be used.
+* @kind problem
+* @precision very-high
+* @problem.severity warning
+* @tags external/autosar/id/a0-1-2
+*       readability
+*       maintainability
+*       external/autosar/allocated-target/implementation
+*       external/autosar/enforcement/automated
+*       external/autosar/obligation/required
+*/
 
 import cpp
 import codingstandards.cpp.autosar
 import semmle.code.cpp.dataflow.DataFlow
 
-// Type isEdgeCase(Expr expr) {
-//   // 1. c-style casts to void.
-//      expr.(CStyleCast).getUnderlyingType()
-//   // 2. Assignment to std::ignore
-// }
+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 acrobatics. */
+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())
+}
 
-from CStyleCast expr
-where any()
-select expr, expr.getType()
+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
@@ -36,21 +52,29 @@ select expr, expr.getType()
  * access of `ret_val`. However, such a case _would_ be flagged by A0-1-1 - Useless assignment.
  */
 
-// from FunctionCall fc, Function f
-// where
-//   not isExcluded(fc, DeadCodePackage::unusedReturnValueQuery()) and
-//   // Find function calls in `ExprStmt`s, which indicate the return value is ignored
-//   fc.getParent() instanceof ExprStmt and
-//   // Ignore calls to void functions, which don't return values
-//   not fc.getUnderlyingType() instanceof VoidType and
-//   // Get the function target
-//   f = fc.getTarget() and
-//   // Overloaded (i.e. user defined) operators should behave in the same way as built-in operators,
-//   // 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 fc.isAffectedByMacro() and
-//   // Rule allows disabling this rule where a static_cast<void> is applied
-//   not fc.getExplicitlyConverted().(StaticCast).getActualType() instanceof VoidType
-// select fc, "Return value from call to $@ is unused.", f, f.getName()
+from FunctionCall fc, Function f
+where
+  not isExcluded(fc, DeadCodePackage::unusedReturnValueQuery()) and
+  // Find function calls in `ExprStmt`s, which indicate the return value is ignored
+  fc.getParent() instanceof ExprStmt and
+  // Ignore calls to void functions, which don't return values
+  not fc.getUnderlyingType() instanceof VoidType and
+  // Get the function target
+  f = fc.getTarget() and
+  // Overloaded (i.e. user defined) operators should behave in the same way as built-in operators,
+  // 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 those results
+  not fc.isAffectedByMacro() and
+  // 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
+  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,5 +20,9 @@ void test_return_val() {
   A a2;
   a1 + a2; // COMPLIANT - `+` is a call to operator+, but is permitted by the
            // rule
-  int y = (int)3;
+
+  (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/test/includes/standard-library/tuple.h

@@ -1,11 +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 
+// TODO change this to example from cpp standard
 struct ignore_t {
-    template <typename T>
-    constexpr // required since C++14
-    void operator=(T&&) const noexcept {}
+  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
+} // namespace std