EssentialTypes: Implement Rule 10.6.

Adds a query which identifies implicit conversions of composite
expressions that cause it to be casted to a wider essential type.

Author: lcartey

c/misra/src/rules/RULE-10-7/ImplicitConversionOfCompositeExpression.ql

@@ -0,0 +1,36 @@
+/**
+ * @id c/misra/implicit-conversion-of-composite-expression
+ * @name RULE-10-7: If a composite expression is used as one operand of an operator in which the usual arithmetic
+ * @description If a composite expression is used as one operand of an operator in which the usual
+ *              arithmetic conversions are performed then the other operand shall not have wider
+ *              essential type
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-10-7
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.c.misra.EssentialTypes
+import codingstandards.c.misra.MisraExpressions
+
+from
+  OperationWithUsualArithmeticConversions arith, CompositeExpression compositeOp, Expr otherOp,
+  Type compositeEssentialType, Type otherOpEssentialType
+where
+  not isExcluded(arith, EssentialTypesPackage::implicitConversionOfCompositeExpressionQuery()) and
+  arith.getAnOperand() = compositeOp and
+  arith.getAnOperand() = otherOp and
+  not otherOp = compositeOp and
+  compositeEssentialType = getEssentialType(compositeOp) and
+  otherOpEssentialType = getEssentialType(otherOp) and
+  compositeEssentialType.getSize() < otherOpEssentialType.getSize() and
+  // Operands of a different type category in an operation with the usual arithmetic conversions is
+  // prohibited by Rule 10.4, so we only report cases here where the essential type categories are
+  // the same
+  getEssentialTypeCategory(compositeEssentialType) = getEssentialTypeCategory(otherOpEssentialType)
+select arith,
+  "Implicit conversion of $@ from " + compositeEssentialType + " to " + otherOpEssentialType,
+  compositeOp, "composite op"

c/misra/test/rules/RULE-10-7/ImplicitConversionOfCompositeExpression.expected

@@ -0,0 +1,3 @@
+| test.c:5:3:5:16 | ... + ... | Implicit conversion of $@ from unsigned short to unsigned int | test.c:5:9:5:16 | ... * ... | composite op |
+| test.c:6:3:6:18 | ... * ... | Implicit conversion of $@ from unsigned short to unsigned int | test.c:6:9:6:17 | ... + ... | composite op |
+| test.c:9:3:9:20 | ... += ... | Implicit conversion of $@ from unsigned short to unsigned int | test.c:9:11:9:19 | ... + ... | composite op |

c/misra/test/rules/RULE-10-7/ImplicitConversionOfCompositeExpression.qlref

@@ -0,0 +1 @@
+rules/RULE-10-7/ImplicitConversionOfCompositeExpression.ql

c/misra/test/rules/RULE-10-7/test.c

@@ -0,0 +1,14 @@
+void testComposite() {
+  unsigned int u32 = 100;
+  unsigned short u16 = 100;
+  u16 + u32 *u16;                 // COMPLIANT
+  u32 + u16 *u16;                 // NON_COMPLIANT
+  u32 *(u16 + u16);               // NON_COMPLIANT
+  u32 *(unsigned int)(u16 + u16); // COMPLIANT
+  u32 + u16 + u16;                // COMPLIANT
+  u32 += (u16 + u16);             // NON_COMPLIANT
+  u32 += (u32 + u16);             // COMPLIANT
+
+  signed int s32 = 100;
+  s32 += (u16 + u16); // // ignored - prohibited by Rule 10.4
+}