Implement Conversions rule package

cpp/common/src/codingstandards/cpp/Call.qll

@@ -0,0 +1,18 @@
+import cpp
+import codingstandards.cpp.types.Type
+
+/**
+ * Gets the `FunctionType` of an expression call.
+ */
+FunctionType getExprCallFunctionType(ExprCall call) {
+  // A standard expression call
+  // Returns a FunctionPointerIshType
+  result = call.(ExprCall).getExpr().getType()
+  or
+  // An expression call using the pointer to member operator (.* or ->*)
+  // This special handling is required because we don't have a CodeQL class representing the call
+  // to a pointer to member function, but the right hand side is extracted as the -1 child of the
+  // call.
+  // Returns a RoutineType
+  result = call.(ExprCall).getChild(-1).getType().(PointerToMemberType).getBaseType()
+}

cpp/common/src/codingstandards/cpp/ConstantExpressions.qll

@@ -0,0 +1,97 @@
+import cpp
+
+final private class FinalExpr = Expr;
+
+/**
+ * An integer constant expression as defined by the C++17 standard.
+ */
+class IntegerConstantExpr extends FinalExpr {
+  IntegerConstantExpr() {
+    // An integer constant expression is a constant expression that has an
+    // integral type.
+    this.isConstant() and
+    exists(Type unspecifiedType | unspecifiedType = this.getUnspecifiedType() |
+      unspecifiedType instanceof IntegralType
+      or
+      // Unscoped enum type
+      unspecifiedType instanceof Enum and
+      not unspecifiedType instanceof ScopedEnum
+    )
+  }
+
+  /**
+   * Gets the value of this integer constant expression.
+   *
+   * This is only defined for expressions that are constant expressions, and
+   * that have a value that can be represented as a `BigInt`.
+   */
+  QlBuiltins::BigInt getConstantValue() {
+    if exists(getPreConversionConstantValue())
+    then result = getPreConversionConstantValue()
+    else result = this.getValue().toBigInt()
+  }
+
+  /**
+   * Gets the pre-conversion constant value of this integer constant expression, if it is different
+   * from `getValue()`.
+   *
+   * This is required because `Expr.getValue()` returns the _converted constant expression value_
+   * for non-literal constant expressions, which is the expression value after conversions have been
+   * applied, but for validating conversions we need the _pre-conversion constant expression value_.
+   */
+  private QlBuiltins::BigInt getPreConversionConstantValue() {
+    // Access of a variable that has a constant initializer
+    result =
+      this.(VariableAccess)
+          .getTarget()
+          .getInitializer()
+          .getExpr()
+          .getFullyConverted()
+          .getValue()
+          .toBigInt()
+    or
+    result = this.(EnumConstantAccess).getTarget().getValue().toBigInt()
+    or
+    result = -this.(UnaryMinusExpr).getOperand().getFullyConverted().getValue().toBigInt()
+    or
+    result = this.(UnaryPlusExpr).getOperand().getFullyConverted().getValue().toBigInt()
+    or
+    result = this.(NotExpr).getOperand().getFullyConverted().getValue().toBigInt().bitNot()
+    or
+    exists(BinaryOperation op, QlBuiltins::BigInt left, QlBuiltins::BigInt right |
+      op = this and
+      left = op.getLeftOperand().getFullyConverted().getValue().toBigInt() and
+      right = op.getRightOperand().getFullyConverted().getValue().toBigInt()
+    |
+      op instanceof AddExpr and
+      result = left + right
+      or
+      op instanceof SubExpr and
+      result = left - right
+      or
+      op instanceof MulExpr and
+      result = left * right
+      or
+      op instanceof DivExpr and
+      result = left / right
+      or
+      op instanceof RemExpr and
+      result = left % right
+      or
+      op instanceof BitwiseAndExpr and
+      result = left.bitAnd(right)
+      or
+      op instanceof BitwiseOrExpr and
+      result = left.bitOr(right)
+      or
+      op instanceof BitwiseXorExpr and
+      result = left.bitXor(right)
+      or
+      op instanceof RShiftExpr and
+      result = left.bitShiftRightSigned(right.toInt())
+      or
+      op instanceof LShiftExpr and
+      result = left.bitShiftLeft(right.toInt())
+    )
+  }
+}

cpp/common/src/codingstandards/cpp/exclusions/cpp/Conversions.qll

@@ -0,0 +1,129 @@
+//** THIS FILE IS AUTOGENERATED, DO NOT MODIFY DIRECTLY.  **/
+import cpp
+import RuleMetadata
+import codingstandards.cpp.exclusions.RuleMetadata
+
+newtype ConversionsQuery =
+  TNoConversionFromBoolQuery() or
+  TNoImplicitBoolConversionQuery() or
+  TNoCharacterNumericalValueQuery() or
+  TInappropriateBitwiseOrShiftOperandsQuery() or
+  TNoSignednessChangeFromPromotionQuery() or
+  TNumericAssignmentTypeMismatchQuery() or
+  TFunctionPointerConversionContextQuery()
+
+predicate isConversionsQueryMetadata(Query query, string queryId, string ruleId, string category) {
+  query =
+    // `Query` instance for the `noConversionFromBool` query
+    ConversionsPackage::noConversionFromBoolQuery() and
+  queryId =
+    // `@id` for the `noConversionFromBool` query
+    "cpp/misra/no-conversion-from-bool" and
+  ruleId = "RULE-7-0-1" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `noImplicitBoolConversion` query
+    ConversionsPackage::noImplicitBoolConversionQuery() and
+  queryId =
+    // `@id` for the `noImplicitBoolConversion` query
+    "cpp/misra/no-implicit-bool-conversion" and
+  ruleId = "RULE-7-0-2" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `noCharacterNumericalValue` query
+    ConversionsPackage::noCharacterNumericalValueQuery() and
+  queryId =
+    // `@id` for the `noCharacterNumericalValue` query
+    "cpp/misra/no-character-numerical-value" and
+  ruleId = "RULE-7-0-3" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `inappropriateBitwiseOrShiftOperands` query
+    ConversionsPackage::inappropriateBitwiseOrShiftOperandsQuery() and
+  queryId =
+    // `@id` for the `inappropriateBitwiseOrShiftOperands` query
+    "cpp/misra/inappropriate-bitwise-or-shift-operands" and
+  ruleId = "RULE-7-0-4" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `noSignednessChangeFromPromotion` query
+    ConversionsPackage::noSignednessChangeFromPromotionQuery() and
+  queryId =
+    // `@id` for the `noSignednessChangeFromPromotion` query
+    "cpp/misra/no-signedness-change-from-promotion" and
+  ruleId = "RULE-7-0-5" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `numericAssignmentTypeMismatch` query
+    ConversionsPackage::numericAssignmentTypeMismatchQuery() and
+  queryId =
+    // `@id` for the `numericAssignmentTypeMismatch` query
+    "cpp/misra/numeric-assignment-type-mismatch" and
+  ruleId = "RULE-7-0-6" and
+  category = "required"
+  or
+  query =
+    // `Query` instance for the `functionPointerConversionContext` query
+    ConversionsPackage::functionPointerConversionContextQuery() and
+  queryId =
+    // `@id` for the `functionPointerConversionContext` query
+    "cpp/misra/function-pointer-conversion-context" and
+  ruleId = "RULE-7-11-3" and
+  category = "required"
+}
+
+module ConversionsPackage {
+  Query noConversionFromBoolQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `noConversionFromBool` query
+      TQueryCPP(TConversionsPackageQuery(TNoConversionFromBoolQuery()))
+  }
+
+  Query noImplicitBoolConversionQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `noImplicitBoolConversion` query
+      TQueryCPP(TConversionsPackageQuery(TNoImplicitBoolConversionQuery()))
+  }
+
+  Query noCharacterNumericalValueQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `noCharacterNumericalValue` query
+      TQueryCPP(TConversionsPackageQuery(TNoCharacterNumericalValueQuery()))
+  }
+
+  Query inappropriateBitwiseOrShiftOperandsQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `inappropriateBitwiseOrShiftOperands` query
+      TQueryCPP(TConversionsPackageQuery(TInappropriateBitwiseOrShiftOperandsQuery()))
+  }
+
+  Query noSignednessChangeFromPromotionQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `noSignednessChangeFromPromotion` query
+      TQueryCPP(TConversionsPackageQuery(TNoSignednessChangeFromPromotionQuery()))
+  }
+
+  Query numericAssignmentTypeMismatchQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `numericAssignmentTypeMismatch` query
+      TQueryCPP(TConversionsPackageQuery(TNumericAssignmentTypeMismatchQuery()))
+  }
+
+  Query functionPointerConversionContextQuery() {
+    //autogenerate `Query` type
+    result =
+      // `Query` type for `functionPointerConversionContext` query
+      TQueryCPP(TConversionsPackageQuery(TFunctionPointerConversionContextQuery()))
+  }
+}

cpp/common/src/codingstandards/cpp/exclusions/cpp/RuleMetadata.qll

@@ -12,6 +12,7 @@ import Comments
 import Concurrency
 import Conditionals
 import Const
+import Conversions
 import DeadCode
 import Declarations
 import ExceptionSafety
@@ -67,6 +68,7 @@ newtype TCPPQuery =
   TConcurrencyPackageQuery(ConcurrencyQuery q) or
   TConditionalsPackageQuery(ConditionalsQuery q) or
   TConstPackageQuery(ConstQuery q) or
+  TConversionsPackageQuery(ConversionsQuery q) or
   TDeadCodePackageQuery(DeadCodeQuery q) or
   TDeclarationsPackageQuery(DeclarationsQuery q) or
   TExceptionSafetyPackageQuery(ExceptionSafetyQuery q) or
@@ -122,6 +124,7 @@ predicate isQueryMetadata(Query query, string queryId, string ruleId, string cat
   isConcurrencyQueryMetadata(query, queryId, ruleId, category) or
   isConditionalsQueryMetadata(query, queryId, ruleId, category) or
   isConstQueryMetadata(query, queryId, ruleId, category) or
+  isConversionsQueryMetadata(query, queryId, ruleId, category) or
   isDeadCodeQueryMetadata(query, queryId, ruleId, category) or
   isDeclarationsQueryMetadata(query, queryId, ruleId, category) or
   isExceptionSafetyQueryMetadata(query, queryId, ruleId, category) or

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

@@ -1,6 +1,7 @@
 import cpp
 import codeql.util.Boolean
 import codingstandards.cpp.types.Graph
+import codingstandards.cpp.types.Type
 
 module TypeNamesMatchConfig implements TypeEquivalenceSig {
   predicate resolveTypedefs() {
@@ -522,24 +523,6 @@ module FunctionDeclarationTypeEquivalence<
   }
 }
 
-/**
- * Convenience class to reduce the awkwardness of how `RoutineType` and `FunctionPointerIshType`
- * don't have a common ancestor.
- */
-private class FunctionType extends Type {
-  FunctionType() { this instanceof RoutineType or this instanceof FunctionPointerIshType }
-
-  Type getReturnType() {
-    result = this.(RoutineType).getReturnType() or
-    result = this.(FunctionPointerIshType).getReturnType()
-  }
-
-  Type getParameterType(int i) {
-    result = this.(RoutineType).getParameterType(i) or
-    result = this.(FunctionPointerIshType).getParameterType(i)
-  }
-}
-
 private class LeafType extends Type {
   LeafType() {
     not this instanceof DerivedType and

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

@@ -94,3 +94,51 @@ 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()
+      )
+  )
+}
+
+/**
+ * The size of the smallest `int` type in the database in bytes.
+ */
+int sizeOfInt() {
+  // The size of int is implementation-defined
+  result =
+    min(int size |
+      size = any(IntType i | i.isSigned()).getCanonicalArithmeticType().getSize()
+    |
+      size
+    )
+}
+
+/**
+ * Convenience class to reduce the awkwardness of how `RoutineType` and `FunctionPointerIshType`
+ * don't have a common ancestor.
+ */
+class FunctionType extends Type {
+  FunctionType() { this instanceof RoutineType or this instanceof FunctionPointerIshType }
+
+  Type getReturnType() {
+    result = this.(RoutineType).getReturnType() or
+    result = this.(FunctionPointerIshType).getReturnType()
+  }
+
+  Type getParameterType(int i) {
+    result = this.(RoutineType).getParameterType(i) or
+    result = this.(FunctionPointerIshType).getParameterType(i)
+  }
+}

cpp/common/test/includes/standard-library/clocale

@@ -1,4 +1,5 @@
-#pragma once
+#ifndef _GHLIBCPP_CLOCALE
+#define _GHLIBCPP_CLOCALE
 
 #define NULL 0
 #define LC_ALL 0
@@ -15,3 +16,5 @@ using ::lconv;
 using ::localeconv;
 using ::setlocale;
 } // namespace std
+
+#endif // _GHLIBCPP_CLOCALE

cpp/common/test/includes/standard-library/cwchar

@@ -0,0 +1,23 @@
+#ifndef _GHLIBCPP_CWCHAR
+#define _GHLIBCPP_CWCHAR
+
+#include "stddef.h"
+
+namespace std {
+// Character classification and conversion types
+typedef struct {
+  int __count;
+  union {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} mbstate_t;
+
+typedef unsigned int wint_t;
+
+// Wide character constants
+static const wint_t WEOF = static_cast<wint_t>(-1);
+
+} // namespace std
+
+#endif // _GHLIBCPP_CWCHAR