Merge branch 'main' into lcartey/cpp-conversions2

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/autosar/src/codingstandards/cpp/CommonTypes.qll

@@ -1,7 +1,7 @@
 import cpp as default
 
 /*
- * Implementations of the C/C++ Fixed Width Types from cstdint.h.
+ * Implementations of the C/C++ Fixed Width Types from cstdint.
  *
  * TODO: Deprecate once this is available in the CodeQL standard library.
  */

cpp/autosar/src/rules/A3-9-1/VariableWidthIntegerTypesUsed.ql

@@ -17,26 +17,10 @@
 
 import cpp
 import codingstandards.cpp.autosar
-import codingstandards.cpp.EncapsulatingFunctions
-import codingstandards.cpp.BuiltInNumericTypes
-import codingstandards.cpp.Type
-import codingstandards.cpp.Operator
+import codingstandards.cpp.rules.variablewidthintegertypesused.VariableWidthIntegerTypesUsed
 
-from Variable v, Type typeStrippedOfSpecifiers
-where
-  not isExcluded(v, DeclarationsPackage::variableWidthIntegerTypesUsedQuery()) and
-  typeStrippedOfSpecifiers = stripSpecifiers(v.getType()) 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
-select v, "Variable '" + v.getName() + "' has variable-width type."
+class VariableWidthIntegerTypesUsedQuery extends VariableWidthIntegerTypesUsedSharedQuery {
+  VariableWidthIntegerTypesUsedQuery() {
+    this = DeclarationsPackage::variableWidthIntegerTypesUsedQuery()
+  }
+}

cpp/autosar/test/rules/A3-9-1/VariableWidthIntegerTypesUsed.qlref

@@ -0,0 +1 @@
+cpp/common/test/rules/variablewidthintegertypesused/VariableWidthIntegerTypesUsed.ql

cpp/autosar/test/rules/A3-9-1/VariableWidthIntegerTypesUsed.testref

@@ -1,3 +1,3 @@
 | test.cpp:4:8:4:8 | c | Variable 'c' has variable-width char type. |
-| test.cpp:38:14:38:15 | c1 | Variable 'c1' has variable-width char type. |
-| test.cpp:56:17:56:18 | c2 | Variable 'c2' has variable-width char type. |
+| test.cpp:10:14:10:15 | c1 | Variable 'c1' has variable-width char type. |
+| test.cpp:14:17:14:18 | c2 | Variable 'c2' has variable-width char type. |

cpp/autosar/test/rules/A3-9-1/VariableWidthPlainCharTypeUsed.expected

@@ -2,88 +2,16 @@
 
 void test_variable_width_type_variables() {
   char c;           // NON_COMPLIANT
-  unsigned char uc; // NON_COMPLIANT
-  signed char sc;   // NON_COMPLIANT
-
-  int i;           // NON_COMPLIANT
-  unsigned int ui; // NON_COMPLIANT
-  unsigned u;      // NON_COMPLIANT
-  signed int si;   // NON_COMPLIANT
-  signed s;        // NON_COMPLIANT
-
-  short sh;           // NON_COMPLIANT
-  unsigned short ush; // NON_COMPLIANT
-  signed short ssh;   // NON_COMPLIANT
-
-  long l;           // NON_COMPLIANT
-  unsigned long ul; // NON_COMPLIANT
-  signed long sl;   // NON_COMPLIANT
-
-  std::int8_t i8;   // COMPLIANT
-  std::int16_t i16; // COMPLIANT
-  std::int32_t i32; // COMPLIANT
-  std::int64_t i64; // COMPLIANT
-
-  std::uint8_t u8;   // COMPLIANT
-  std::uint16_t u16; // COMPLIANT
-  std::uint32_t u32; // COMPLIANT
-  std::uint64_t u64; // COMPLIANT
-}
-
-int main(int argc, char *argv[]) { // COMPLIANT
-  // main as an exception
+  unsigned char uc; // COMPLIANT - covered by VariableWidthIntegerTypesUsed
+  signed char sc;   // COMPLIANT - covered by VariableWidthIntegerTypesUsed
 }
 
 void test_variable_width_type_qualified_variables() {
   const char c1 = 0;           // NON_COMPLIANT
-  const unsigned char uc1 = 0; // NON_COMPLIANT
-  const signed char sc1 = 0;   // NON_COMPLIANt
-
-  const int i1 = 0;           // NON_COMPLIANT
-  const unsigned int ui1 = 0; // NON_COMPLIANT
-  const unsigned u1 = 0;      // NON_COMPLIANT
-  const signed int si1 = 0;   // NON_COMPLIANT
-  const signed s1 = 0;        // NON_COMPLIANT
-
-  const short sh1 = 0;           // NON_COMPLIANT
-  const unsigned short ush1 = 0; // NON_COMPLIANT
-  const signed short ssh1 = 0;   // NON_COMPLIANT
-
-  const long l1 = 0;           // NON_COMPLIANT
-  const unsigned long ul1 = 0; // NON_COMPLIANT
-  const signed long sl1 = 0;   // NON_COMPLIANT
+  const unsigned char uc1 = 0; // COMPLIANT - (VariableWidthIntegerTypesUsed)
+  const signed char sc1 = 0;   // COMPLIANT - (VariableWidthIntegerTypesUsed)
 
   volatile char c2;           // NON_COMPLIANT
-  volatile unsigned char uc2; // NON_COMPLIANT
-  volatile signed char sc2;   // NON_COMPLIANt
-
-  volatile int i2;           // NON_COMPLIANT
-  volatile unsigned int ui2; // NON_COMPLIANT
-  volatile unsigned u2;      // NON_COMPLIANT
-  volatile signed int si2;   // NON_COMPLIANT
-  volatile signed s2;        // NON_COMPLIANT
-
-  volatile short sh2;           // NON_COMPLIANT
-  volatile unsigned short ush2; // NON_COMPLIANT
-  volatile signed short ssh2;   // NON_COMPLIANT
-
-  volatile long l2;           // NON_COMPLIANT
-  volatile unsigned long ul2; // NON_COMPLIANT
-  volatile signed long sl2;   // NON_COMPLIANT
-}
-
-struct test_fix_fp_614 {
-  test_fix_fp_614 operator++(int); // COMPLIANT
-  test_fix_fp_614 operator--(int); // COMPLIANT
-};
-
-// COMPLIANT - instantiated with Fixed Width Types.
-template <typename MyType> constexpr void test_fix_fp_540(MyType value) {
-  value++;
-}
-
-int call_test_fix_fp_540() {
-  test_fix_fp_540<std::uint8_t>(19);
-  test_fix_fp_540<std::int16_t>(20);
-  return 0;
-}
+  volatile unsigned char uc2; // COMPLIANT - (VariableWidthIntegerTypesUsed)
+  volatile signed char sc2;   // COMPLIANT - (VariableWidthIntegerTypesUsed)
+}

cpp/autosar/test/rules/A3-9-1/test.cpp

@@ -0,0 +1,69 @@
+/**
+ * A library for supporting the consistent detection of banned functions in C++ code.
+ */
+
+import cpp
+import AlertReporting
+
+/**
+ * A signature for a banned function.
+ */
+signature class BannedFunction extends Function;
+
+/**
+ * A module for detecting uses of banned functions in C++ code.
+ */
+module BannedFunctions<BannedFunction F> {
+  final private class FinalExpr = Expr;
+
+  /**
+   * An expression that uses a banned function.
+   *
+   * It can be either a function call or a function access (taking the address of the function).
+   */
+  class UseExpr extends FinalExpr {
+    string action;
+    F bannedFunction;
+
+    UseExpr() {
+      this.(FunctionCall).getTarget() = bannedFunction and
+      action = "Call to"
+      or
+      this.(FunctionAccess).getTarget() = bannedFunction and
+      action = "Address taken for"
+    }
+
+    string getFunctionName() { result = bannedFunction.getName() }
+
+    string getAction() { result = action }
+
+    Element getPrimaryElement() {
+      // If this is defined in a macro in the users source location, then report the macro
+      // expansion, otherwise report the element itself. This ensures that we always report
+      // the use of the terminating function, but combine usages when the macro is defined
+      // by the user.
+      exists(Element e | e = MacroUnwrapper<UseExpr>::unwrapElement(this) |
+        if exists(e.getFile().getRelativePath()) then result = e else result = this
+      )
+    }
+  }
+
+  final private class FinalElement = Element;
+
+  /**
+   * A `Use` of a banned function.
+   *
+   * This is an `Element` in a program which represents the use of a banned function.
+   * For uses within macro expansions, this may report the location of the macro, if
+   * it is defined within the user's source code.
+   */
+  class Use extends FinalElement {
+    UseExpr use;
+
+    Use() { this = use.getPrimaryElement() }
+
+    string getFunctionName() { result = use.getFunctionName() }
+
+    string getAction() { result = use.getAction() }
+  }
+}

cpp/common/src/codingstandards/cpp/BannedFunctions.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 }
+}