VariableWidthIntegerTypesUsed - support function return types

Expand support for A3-9-1 and MISRA C++ 2023 6.9.2 to include the
use of integers in function return types.

Author: lcartey

change_notes/2025-06-10-a3-9-1-functions.md

@@ -0,0 +1,2 @@
+ - `A3-9-1` - `VariableWidthIntegerTypesUsed.ql`:
+   - This query now reports the use of non-fixed width integer types in function return types, with the exception of `char` types and for `main` functions.

cpp/common/src/codingstandards/cpp/BuiltInNumericTypes.qll

@@ -20,3 +20,10 @@ class BuiltInIntegerType extends BuiltInType {
 class ExcludedVariable extends Parameter {
   ExcludedVariable() { getFunction() instanceof MainFunction }
 }
+
+/**
+ * Any main function.
+ */
+class ExcludedFunction extends Function {
+  ExcludedFunction() { this instanceof MainFunction }
+}

cpp/common/src/codingstandards/cpp/rules/variablewidthintegertypesused/VariableWidthIntegerTypesUsed.qll

@@ -16,23 +16,37 @@ abstract class VariableWidthIntegerTypesUsedSharedQuery extends Query { }
 
 Query getQuery() { result instanceof VariableWidthIntegerTypesUsedSharedQuery }
 
-query predicate problems(Variable v, string message) {
-  not isExcluded(v, getQuery()) and
-  exists(Type typeStrippedOfSpecifiers |
-    typeStrippedOfSpecifiers = stripSpecifiers(v.getType()) and
+query predicate problems(Element e, string message) {
+  not isExcluded(e, getQuery()) and
+  exists(Type typeStrippedOfSpecifiers, Type rawType |
+    typeStrippedOfSpecifiers = stripSpecifiers(rawType) and
     (
       typeStrippedOfSpecifiers instanceof BuiltInIntegerType or
       typeStrippedOfSpecifiers instanceof UnsignedCharType or
       typeStrippedOfSpecifiers instanceof SignedCharType
-    ) and
-    not v instanceof ExcludedVariable and
-    // Dont consider template instantiations because instantiations with
-    // Fixed Width Types are recorded after stripping their typedef'd type,
-    // thereby, causing false positives (#540).
-    not v.isFromTemplateInstantiation(_) and
-    //post-increment/post-decrement operators are required by the standard to have a dummy int parameter
-    not v.(Parameter).getFunction() instanceof PostIncrementOperator and
-    not v.(Parameter).getFunction() instanceof PostDecrementOperator
-  ) and
-  message = "Variable '" + v.getName() + "' has variable-width type."
-}
+    )
+  |
+    exists(Variable v | v = e |
+      v.getType() = rawType and
+      not v instanceof ExcludedVariable and
+      // Dont consider template instantiations because instantiations with
+      // Fixed Width Types are recorded after stripping their typedef'd type,
+      // thereby, causing false positives (#540).
+      not v.isFromTemplateInstantiation(_) and
+      //post-increment/post-decrement operators are required by the standard to have a dummy int parameter
+      not v.(Parameter).getFunction() instanceof PostIncrementOperator and
+      not v.(Parameter).getFunction() instanceof PostDecrementOperator and
+      message = "Variable '" + v.getName() + "' has variable-width type."
+    )
+    or
+    exists(Function f | f = e |
+      f.getType() = rawType and
+      not f instanceof ExcludedFunction and
+      // Dont consider template instantiations because instantiations with
+      // Fixed Width Types are recorded after stripping their typedef'd type,
+      // thereby, causing false positives (#540).
+      not f.isFromTemplateInstantiation(_) and
+      message = "Function '" + f.getName() + "' has variable-width return type."
+    )
+  )
+}

cpp/common/test/rules/variablewidthintegertypesused/test.cpp

@@ -82,8 +82,74 @@ template <typename MyType> constexpr void test_fix_fp_540(MyType value) {
   value++;
 }
 
-int call_test_fix_fp_540() {
+void call_test_fix_fp_540() {
   test_fix_fp_540<std::uint8_t>(19);
   test_fix_fp_540<std::int16_t>(20);
-  return 0;
+}
+
+char test_char_return() { // COMPLIANT
+  return 'a';
+}
+unsigned char test_unsigned_char_return() { // NON_COMPLIANT
+  return 'b';
+}
+signed char test_signed_char_return() { // NON_COMPLIANT
+  return 'c';
+}
+int test_int_return() { // NON_COMPLIANT
+  return 42;
+}
+unsigned int test_unsigned_int_return() { // NON_COMPLIANT
+  return 43;
+}
+unsigned test_unsigned_return() { // NON_COMPLIANT
+  return 44;
+}
+signed int test_signed_int_return() { // NON_COMPLIANT
+  return 45;
+}
+signed test_signed_return() { // NON_COMPLIANT
+  return 46;
+}
+short test_short_return() { // NON_COMPLIANT
+  return 47;
+}
+unsigned short test_unsigned_short_return() { // NON_COMPLIANT
+  return 48;
+}
+signed short test_signed_short_return() { // NON_COMPLIANT
+  return 49;
+}
+long test_long_return() { // NON_COMPLIANT
+  return 50;
+}
+unsigned long test_unsigned_long_return() { // NON_COMPLIANT
+  return 51;
+}
+signed long test_signed_long_return() { // NON_COMPLIANT
+  return 52;
+}
+std::int8_t test_int8_t_return() { // COMPLIANT
+  return 53;
+}
+std::int16_t test_int16_t_return() { // COMPLIANT
+  return 54;
+}
+std::int32_t test_int32_t_return() { // COMPLIANT
+  return 55;
+}
+std::int64_t test_int64_t_return() { // COMPLIANT
+  return 56;
+}
+std::uint8_t test_uint8_t_return() { // COMPLIANT
+  return 57;
+}
+std::uint16_t test_uint16_t_return() { // COMPLIANT
+  return 58;
+}
+std::uint32_t test_uint32_t_return() { // COMPLIANT
+  return 59;
+}
+std::uint64_t test_uint64_t_return() { // COMPLIANT
+  return 60;
 }

rule_packages/cpp/Declarations.json

@@ -92,7 +92,7 @@
             "maintainability"
           ],
           "implementation_scope": {
-            "description": "This implementation excludes the plain char type from consideration."
+            "description": "This implementation excludes the plain char type. It also excludes the use of standard integer types in the definition of main functions, and the use of an integer parameter in the declaration of postfix operators."
           },
           "shared_implementation_short_name": "VariableWidthIntegerTypesUsed"
         },