Exclude literals that are the result of constexpr variable uses.

Author: rvermeulen

cpp/autosar/src/rules/A5-1-1/LiteralValueUsedOutsideTypeInit.ql

@@ -51,7 +51,8 @@ where
   // Aggregate literal
   not l = any(ArrayOrVectorAggregateLiteral aal).getAnElementExpr(_).getAChild*() and
   // Ignore x - 1 expressions
-  not exists(SubExpr se | se.getRightOperand() = l and l.getValue() = "1")
+  not exists(SubExpr se | se.getRightOperand() = l and l.getValue() = "1") and
+  not l instanceof CompileTimeComputedIntegralLiteral 
 select l,
   "Literal value " + getTruncatedLiteralText(l) + " used outside of type initialization " +
     l.getAPrimaryQlClass()

cpp/autosar/test/rules/A5-1-1/LiteralValueUsedOutsideTypeInit.expected

@@ -3,3 +3,7 @@
 | test.cpp:54:7:54:7 | 1 | Literal value 1 used outside of type initialization Literal |
 | test.cpp:75:23:75:28 | test | Literal value "test" used outside of type initialization StringLiteral |
 | test.cpp:76:19:76:28 | not okay | Literal value "not okay" used outside of type initialization StringLiteral |
+| test.cpp:104:8:104:8 | 4 | Literal value 4 used outside of type initialization Literal |
+| test.cpp:104:8:104:8 | 4 | Literal value 4 used outside of type initialization Literal |
+| test.cpp:104:8:104:8 | 4 | Literal value 4 used outside of type initialization Literal |
+| test.cpp:108:18:108:18 | 1 | Literal value 1 used outside of type initialization Literal |

cpp/autosar/test/rules/A5-1-1/test.cpp

@@ -80,10 +80,32 @@ void test_not_wrapper_stream(std::ostream &os, const char *str) noexcept {
 #define MACRO_LOG(test_str)                                                    \
   do {                                                                         \
     struct test_struct {                                                       \
-      static const char *get_str() { return static_cast<char *>(test_str); }   \
+      static const char *get_str() {                                           \
+        return static_cast<const char *>(test_str);                            \
+      }                                                                        \
     };                                                                         \
   } while (false)
 
 void f() {
   MACRO_LOG("test"); // COMPLIANT - exclusion
+}
+
+template <typename T> struct S1 { static constexpr size_t value(); };
+
+template <> struct S1<int> {
+  static constexpr size_t value() { return sizeof(int); };
+};
+
+constexpr size_t g1 = S1<int>::value();
+constexpr size_t f1() { return sizeof(int); }
+
+template <typename T, int size> struct S2 {
+  T m1[size]; // COMPLIANT
+  T m2[4];    // NON_COMPLIANT
+};
+
+void test_fp_reported_in_371() {
+  struct S2<int, 1> l1;    // COMPLIANT[FALSE_POSITIVE]
+  struct S2<int, g1> l2;   // COMPLIANT
+  struct S2<int, f1()> l3; // COMPLIANT
 }

cpp/common/src/codingstandards/cpp/Literals.qll

@@ -28,3 +28,22 @@ class Utf16StringLiteral extends StringLiteral {
 class Utf32StringLiteral extends StringLiteral {
   Utf32StringLiteral() { this.getValueText().regexpMatch("(?s)\\s*U\".*") }
 }
+
+/**
+ * A literal resulting from the use of a constexpr
+ * variable, or macro expansion.
+ */
+class CompileTimeComputedIntegralLiteral extends Literal {
+  CompileTimeComputedIntegralLiteral() {
+    this.getUnspecifiedType() instanceof IntegralType and
+    not this.getUnspecifiedType() instanceof BoolType and
+    not this.getUnspecifiedType() instanceof CharType and
+    // In some cases we still type char constants like '.' as int
+    not this.getValueText().trim().matches("'%'") and
+    not this.getValueText()
+        .trim()
+        .regexpMatch("([0-9][0-9']*|0[xX][0-9a-fA-F']+|0b[01']+)[uU]?([lL]{1,2}|[zZ])?") and
+    // Exclude class field initializers whose value text equals the initializer expression, e.g., `x(0)`
+    not any(ConstructorFieldInit cfi).getExpr() = this
+  }
+}