EssentialTypes: Implement Rule 10.4

Adds a query that finds operands to operators with the usual arithmetic
conversions that are incompatible.

Author: lcartey

c/misra/src/rules/RULE-10-4/OperandsWithMismatchedEssentialTypeCategory.ql

@@ -0,0 +1,57 @@
+/**
+ * @id c/misra/operands-with-mismatched-essential-type-category
+ * @name RULE-10-4: Both operands of an operator in which the usual arithmetic conversions are performed shall have the
+ * @description Both operands of an operator in which the usual arithmetic conversions are performed
+ *              shall have the same essential type category
+ * @kind problem
+ * @precision very-high
+ * @problem.severity error
+ * @tags external/misra/id/rule-10-4
+ *       external/misra/obligation/required
+ */
+
+import cpp
+import codingstandards.c.misra
+import codingstandards.c.misra.EssentialTypes
+import codingstandards.c.misra.MisraExpressions
+
+from
+  OperationWithUsualArithmeticConversions op, Type leftOpEssentialType, Type rightOpEssentialType,
+  EssentialTypeCategory leftOpTypeCategory, EssentialTypeCategory rightOpTypeCategory,
+  string message
+where
+  not isExcluded(op, EssentialTypesPackage::operandsWithMismatchedEssentialTypeCategoryQuery()) and
+  leftOpEssentialType = getEssentialType(op.getLeftOperand()) and
+  rightOpEssentialType = getEssentialType(op.getRightOperand()) and
+  leftOpTypeCategory = getEssentialTypeCategory(leftOpEssentialType) and
+  rightOpTypeCategory = getEssentialTypeCategory(rightOpEssentialType) and
+  (
+    not leftOpTypeCategory = rightOpTypeCategory and
+    message =
+      "The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: "
+        + leftOpTypeCategory + ", right operand: " + rightOpTypeCategory + ")."
+    or
+    // This is not technically covered by the rule, but the examples make it clear that this should
+    // be reported as non-compliant.
+    leftOpTypeCategory = EssentiallyEnumType() and
+    rightOpTypeCategory = EssentiallyEnumType() and
+    not leftOpEssentialType = rightOpEssentialType and
+    message =
+      "The operands of this operator with usual arithmetic conversions have mismatched essentially Enum types (left operand: "
+        + leftOpEssentialType + ", right operand: " + rightOpEssentialType + ")."
+  ) and
+  not (
+    // Mismatch is permitted if using "+" or "+=" with one character operand and one integer operand
+    op.getOperator() = ["+", "+="] and
+    [leftOpTypeCategory, rightOpTypeCategory] = EssentiallyCharacterType() and
+    [leftOpTypeCategory, rightOpTypeCategory] =
+      [EssentiallyUnsignedType().(TEssentialTypeCategory), EssentiallySignedType()]
+  ) and
+  not (
+    // Mismatch is permitted if using "+" or "+=" with one pointer operand and one integer operand
+    op.getOperator() = ["-", "-="] and
+    leftOpTypeCategory = EssentiallyCharacterType() and
+    rightOpTypeCategory =
+      [EssentiallyUnsignedType().(TEssentialTypeCategory), EssentiallySignedType()]
+  )
+select op, message

c/misra/test/rules/RULE-10-4/OperandsWithMismatchedEssentialTypeCategory.expected

@@ -0,0 +1,10 @@
+| test.c:14:3:14:9 | ... + ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Unsigned type, right operand: essentially Signed type). |
+| test.c:15:3:15:9 | ... + ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Signed type, right operand: essentially Unsigned type). |
+| test.c:16:3:16:10 | ... += ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Signed type, right operand: essentially Unsigned type). |
+| test.c:17:3:17:9 | ... + ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Floating type, right operand: essentially Signed type). |
+| test.c:18:3:18:9 | ... + ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Signed type, right operand: essentially Floating type). |
+| test.c:19:3:19:10 | ... += ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Signed type, right operand: essentially Floating type). |
+| test.c:27:3:27:9 | ... - ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Signed type, right operand: essentially Character type). |
+| test.c:28:3:28:10 | ... -= ... | The operands of this operator with usual arithmetic conversions have mismatched essential types (left operand: essentially Signed type, right operand: essentially Character type). |
+| test.c:34:3:34:11 | ... < ... | The operands of this operator with usual arithmetic conversions have mismatched essentially Enum types (left operand: E1, right operand: E2). |
+| test.c:35:3:35:7 | ... < ... | The operands of this operator with usual arithmetic conversions have mismatched essentially Enum types (left operand: E1, right operand: E2). |

c/misra/test/rules/RULE-10-4/OperandsWithMismatchedEssentialTypeCategory.qlref

@@ -0,0 +1 @@
+rules/RULE-10-4/OperandsWithMismatchedEssentialTypeCategory.ql

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

@@ -0,0 +1,36 @@
+void testOps() {
+  signed int s32 = 100;
+  signed long long s64 = 100;
+  unsigned int u = 100;
+  float f = 10.0f;
+  char c = 'A';
+
+  s32 + s32;  // COMPLIANT
+  s64 + s64;  // COMPLIANT
+  s32 + s64;  // COMPLIANT
+  s64 + s32;  // COMPLIANT
+  s64 += s32; // COMPLIANT
+  s32 += s64; // COMPLIANT
+  u + s32;    // NON_COMPLIANT
+  s32 + u;    // NON_COMPLIANT
+  s32 += u;   // NON_COMPLIANT
+  f + s32;    // NON_COMPLIANT
+  s32 + f;    // NON_COMPLIANT
+  s32 += f;   // NON_COMPLIANT
+
+  c + s32;  // COMPLIANT - by exception
+  c += s32; // COMPLIANT - by exception
+  s32 + c;  // COMPLIANT - by exception
+  s32 += c; // COMPLIANT - by exception
+  c - s32;  // COMPLIANT - by exception
+  c -= s32; // COMPLIANT - by exception
+  s32 - c;  // NON_COMPLIANT
+  s32 -= c; // NON_COMPLIANT
+
+  enum E1 { A, B, C } e1a;
+  enum E2 { D, E, F } e2a;
+  e1a < e1a; // COMPLIANT
+  A < A;     // COMPLIANT
+  e1a < e2a; // NON_COMPLIANT
+  A < D;     // NON_COMPLIANT
+}