Merge pull request #919 from github/lcartey/cpp-conversions

Implement `Conversions` rule package

Author: MichaelRFairhurst

cpp/common/src/codingstandards/cpp/BinaryOperations.qll

@@ -0,0 +1,75 @@
+import cpp
+
+private signature class BinaryOp extends BinaryOperation;
+
+private signature class AssignBinaryOp extends AssignOperation;
+
+/**
+ * A module for unifying the `BinaryOperation` and `AssignOperation` hierarchies.
+ */
+private module BinaryOpUnifier<BinaryOp BinaryOpType, AssignBinaryOp AssignBinaryOpType> {
+  final class FinalExpr = Expr;
+
+  class BinaryExpr extends FinalExpr {
+    BinaryExpr() {
+      this instanceof BinaryOpType or
+      this instanceof AssignBinaryOpType
+    }
+
+    Expr getLeftOperand() {
+      result = this.(BinaryOpType).getLeftOperand()
+      or
+      result = this.(AssignBinaryOpType).getLValue()
+    }
+
+    Expr getRightOperand() {
+      result = this.(BinaryOpType).getRightOperand()
+      or
+      result = this.(AssignBinaryOpType).getRValue()
+    }
+
+    string getOperator() {
+      result = this.(BinaryOpType).getOperator()
+      or
+      result = this.(AssignBinaryOpType).getOperator()
+    }
+  }
+}
+
+/**
+ * A binary shift operation (`<<` or `>>`).
+ */
+class BinaryShiftOperation extends BinaryOperation {
+  BinaryShiftOperation() {
+    this instanceof LShiftExpr or
+    this instanceof RShiftExpr
+  }
+}
+
+/**
+ * A binary shift assignment operation (`<<=` or `>>=`).
+ */
+class AssignShiftOperation extends AssignOperation {
+  AssignShiftOperation() {
+    this instanceof AssignLShiftExpr or
+    this instanceof AssignRShiftExpr
+  }
+}
+
+/**
+ * A binary bitwise operation or binary bitwise assignment operation, including shift operations.
+ */
+class BinaryBitwiseOpOrAssignOp =
+  BinaryOpUnifier<BinaryBitwiseOperation, AssignBitwiseOperation>::BinaryExpr;
+
+/**
+ * A binary shift operation (`<<` or `>>`) or shift assignment operation (`<<=` or `>>=`).
+ */
+class BinaryShiftOpOrAssignOp =
+  BinaryOpUnifier<BinaryShiftOperation, AssignShiftOperation>::BinaryExpr;
+
+/**
+ * A binary arithmetic operation or binary arithmetic assignment operation.
+ */
+class BinaryArithmeticOpOrAssignOp =
+  BinaryOpUnifier<BinaryArithmeticOperation, AssignArithmeticOperation>::BinaryExpr;

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

@@ -0,0 +1,19 @@
+import cpp
+import codingstandards.cpp.types.Type
+import codingstandards.cpp.types.FunctionType
+
+/**
+ * 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.(ComplementExpr).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/CanonicalTypes.qll

@@ -0,0 +1,23 @@
+import cpp
+
+/**
+ * One of the 10 canonical integer types, which are the standard integer types.
+ */
+class CanonicalIntegralType extends IntegralType {
+  CanonicalIntegralType() { this = this.getCanonicalArithmeticType() }
+
+  /**
+   * Holds if this is the canonical integer type with the shortest name for its size.
+   */
+  predicate isMinimal() {
+    not exists(CanonicalIntegralType other |
+      other.getSize() = this.getSize() and
+      (
+        other.isSigned() and this.isSigned()
+        or
+        other.isUnsigned() and this.isUnsigned()
+      ) and
+      other.getName().length() < this.getName().length()
+    )
+  }
+}

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
 import codingstandards.cpp.types.FunctionType
 
 module TypeNamesMatchConfig implements TypeEquivalenceSig {
@@ -526,7 +527,6 @@ module FunctionDeclarationTypeEquivalence<
 private class LeafType extends Type {
   LeafType() {
     not this instanceof DerivedType and
-    not this instanceof FunctionType and
     not this instanceof FunctionType
   }
 }