Rule 7.0.6: Use BigInt for constant expressions

 - Use IntegerConstantExpr to determine both the expressions which
   are constant, and the BigInt value of those constants (before
   final conversion).
 - Implement a BigInt type upper/lower bound to determine whether
   a constant assignment is valid.

Author: lcartey

cpp/common/src/codingstandards/cpp/types/Type.qll

@@ -94,3 +94,20 @@ int getPrecision(IntegralType type) {
   or
   type.isExplicitlySigned() and result = type.getSize() * 8 - 1
 }
+
+/**
+ * Determines the lower and upper bounds of an integral type.
+ */
+predicate integralTypeBounds(IntegralType integralType, QlBuiltins::BigInt lb, QlBuiltins::BigInt ub) {
+  exists(QlBuiltins::BigInt limit | limit = 2.toBigInt().pow(8 * integralType.getSize()) |
+    if integralType instanceof BoolType
+    then lb = 0.toBigInt() and ub = 1.toBigInt()
+    else
+      if integralType.isSigned()
+      then (
+        lb = -(limit / 2.toBigInt()) and ub = (limit / 2.toBigInt()) - 1.toBigInt()
+      ) else (
+        lb = 0.toBigInt() and ub = limit - 1.toBigInt()
+      )
+  )
+}

cpp/misra/src/codingstandards/cpp/misra/StandardConversions.qll

@@ -1,5 +1,6 @@
 import cpp
 import codingstandards.cpp.misra
+import codingstandards.cpp.Type
 
 /**
  * A MISRA C++ 2023 type category.
@@ -95,9 +96,15 @@ class NumericType extends Type {
 
   TypeCategory getTypeCategory() { result = getTypeCategory(realType) }
 
-  float getUpperBound() { result = typeUpperBound(realType) }
+  /**
+   * Gets the integeral upper bound of the numeric type, if it represents an integer type.
+   */
+  QlBuiltins::BigInt getIntegralUpperBound() { integralTypeBounds(realType, _, result) }
 
-  float getLowerBound() { result = typeLowerBound(realType) }
+  /**
+   * Gets the integeral lower bound of the numeric type, if it represents an integer type.
+   */
+  QlBuiltins::BigInt getIntegralLowerBound() { integralTypeBounds(realType, result, _) }
 
   Type getRealType() { result = realType }
 }

cpp/misra/src/rules/RULE-7-0-6/NumericAssignmentTypeMismatch.ql

@@ -15,34 +15,39 @@
 
 import cpp
 import codingstandards.cpp.misra
+import codingstandards.cpp.ConstantExpressions
 import codingstandards.cpp.misra.StandardConversions
+import semmle.code.cpp.rangeanalysis.SimpleRangeAnalysis
 
-predicate isValidConstantAssignment(Expr source, NumericType targetType) {
+predicate isValidConstantAssignment(IntegerConstantExpr source, NumericType targetType) {
   isAssignment(source, targetType, _) and
-  // Source is an integer constant expression
-  source.isConstant() and
-  source.getType().(NumericType).getTypeCategory() = Integral() and
-  exists(float val | val = source.getValue().toFloat() |
+  exists(QlBuiltins::BigInt val | val = source.getConstantValue() |
     // Bit field assignment: check if the value fits in the bit field
     exists(BitField bf, int numBits |
       isAssignedToBitfield(source, bf) and
       numBits = bf.getNumBits() and
       if targetType.getSignedness() = Signed()
       then
         // Signed bit field: value must be in the range of signed bit field
-        val >= -2.pow(numBits - 1) and
-        val < 2.pow(numBits - 1)
+        val >= -2.toBigInt().pow(numBits - 1) and
+        val < 2.toBigInt().pow(numBits - 1)
       else (
         // Unsigned bit field: value must be in the range of unsigned bit field
-        val >= 0 and
-        val < 2.pow(numBits)
+        val >= 0.toBigInt() and
+        val < 2.toBigInt().pow(numBits)
       )
     )
     or
     // Regular assignment: check if the value fits in the target type range
     not isAssignedToBitfield(source, _) and
-    targetType.getLowerBound() <= val and
-    val <= targetType.getUpperBound()
+    (
+      // Integer types: check if the value fits in the target type range
+      targetType.getIntegralLowerBound() <= val and
+      val <= targetType.getIntegralUpperBound()
+      or
+      // All floating point types can represent all integer values
+      targetType.getTypeCategory() = FloatingPoint()
+    )
   )
 }