EssentialTypes: Update metadata

lcartey · lcartey · commit c6ce829e8cff · 2023-02-14T14:11:05.000Z
diff --git a/c/misra/src/rules/RULE-10-1/OperandsOfAnInappropriateEssentialType.ql b/c/misra/src/rules/RULE-10-1/OperandsOfAnInappropriateEssentialType.ql
@@ -1,11 +1,13 @@
 /**
  * @id c/misra/operands-of-an-inappropriate-essential-type
  * @name RULE-10-1: Operands shall not be of an inappropriate essential type
- * @description
+ * @description Using an inappropriate essential type operand may lead to confusing or unexpected
+ *              behavior when the operand is converted.
  * @kind problem
  * @precision very-high
- * @problem.severity error
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-1
+ *       maintainability
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-1/PointerTypeOnLogicalOperator.ql b/c/misra/src/rules/RULE-10-1/PointerTypeOnLogicalOperator.ql
@@ -1,11 +1,13 @@
 /**
  * @id c/misra/pointer-type-on-logical-operator
  * @name RULE-10-1: Logical operators should not be used with pointer types
- * @description
+ * @description Using pointer types with logical operators should be avoid because it can cause
+ *              confusing behavior.
  * @kind problem
  * @precision very-high
- * @problem.severity error
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-1
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-2/AdditionSubtractionOnEssentiallyCharType.ql b/c/misra/src/rules/RULE-10-2/AdditionSubtractionOnEssentiallyCharType.ql
@@ -1,12 +1,14 @@
 /**
  * @id c/misra/addition-subtraction-on-essentially-char-type
- * @name RULE-10-2: Expressions of essentially character type shall not be used inappropriately in addition and
+ * @name RULE-10-2: Inappropriate use of essentially character type operands in addition and subtraction operations
  * @description Expressions of essentially character type shall not be used inappropriately in
  *              addition and subtraction operations
  * @kind problem
  * @precision very-high
  * @problem.severity error
  * @tags external/misra/id/rule-10-2
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-3/AssignmentOfIncompatibleEssentialType.ql b/c/misra/src/rules/RULE-10-3/AssignmentOfIncompatibleEssentialType.ql
@@ -1,12 +1,14 @@
 /**
  * @id c/misra/assignment-of-incompatible-essential-type
- * @name RULE-10-3: The value of an expression shall not be assigned to an object with a narrower essential type or of a
+ * @name RULE-10-3: Do not assign to an object with a different essential type category or narrower essential type
  * @description The value of an expression shall not be assigned to an object with a narrower
  *              essential type or of a different essential type category
  * @kind problem
- * @precision high
- * @problem.severity error
+ * @precision very-high
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-3
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-4/OperandsWithMismatchedEssentialTypeCategory.ql b/c/misra/src/rules/RULE-10-4/OperandsWithMismatchedEssentialTypeCategory.ql
@@ -1,12 +1,14 @@
 /**
  * @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
+ * @name RULE-10-4: Operator with usual arithmetic conversions shall have operands with the same essential type category
  * @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
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-4
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-5/InappropriateEssentialTypeCast.ql b/c/misra/src/rules/RULE-10-5/InappropriateEssentialTypeCast.ql
@@ -1,11 +1,14 @@
 /**
  * @id c/misra/inappropriate-essential-type-cast
  * @name RULE-10-5: The value of an expression should not be cast to an inappropriate essential type
- * @description
+ * @description Casting the value of an expression to an inappropriate essential type may lead to
+ *              confusing or unexpected behavior in the way the value is converted.
  * @kind problem
  * @precision very-high
- * @problem.severity error
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-5
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/advisory
  */
 
diff --git a/c/misra/src/rules/RULE-10-6/AssignmentToWiderEssentialType.ql b/c/misra/src/rules/RULE-10-6/AssignmentToWiderEssentialType.ql
@@ -1,11 +1,14 @@
 /**
  * @id c/misra/assignment-to-wider-essential-type
  * @name RULE-10-6: The value of a composite expression shall not be assigned to an object with wider essential type
- * @description
+ * @description Assigning a composite expression to an object with wider essential type can cause
+ *              some unexpected conversions.
  * @kind problem
  * @precision very-high
- * @problem.severity error
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-6
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-7/ImplicitConversionOfCompositeExpression.ql b/c/misra/src/rules/RULE-10-7/ImplicitConversionOfCompositeExpression.ql
@@ -1,13 +1,15 @@
 /**
  * @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
+ * @name RULE-10-7: Implicit conversion of composite expression operand to wider essential type
  * @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
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-7
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-10-8/InappropriateCastOfCompositeExpression.ql b/c/misra/src/rules/RULE-10-8/InappropriateCastOfCompositeExpression.ql
@@ -1,12 +1,14 @@
 /**
  * @id c/misra/inappropriate-cast-of-composite-expression
- * @name RULE-10-8: The value of a composite expression shall not be cast to a different essential type category or a
+ * @name RULE-10-8: Composite expression explicitly casted to wider or different essential type
  * @description The value of a composite expression shall not be cast to a different essential type
  *              category or a wider essential type
  * @kind problem
  * @precision very-high
- * @problem.severity error
+ * @problem.severity warning
  * @tags external/misra/id/rule-10-8
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-14-1/LoopOverEssentiallyFloatType.ql b/c/misra/src/rules/RULE-14-1/LoopOverEssentiallyFloatType.ql
@@ -1,11 +1,13 @@
 /**
  * @id c/misra/loop-over-essentially-float-type
  * @name RULE-14-1: A loop counter shall not have essentially floating type
- * @description
+ * @description A floating point loop counter can cause confusing behavior when incremented.
  * @kind problem
- * @precision high
- * @problem.severity error
+ * @precision very-high
+ * @problem.severity warning
  * @tags external/misra/id/rule-14-1
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/c/misra/src/rules/RULE-21-16/MemcmpOnInappropriateEssentialTypeArgs.ql b/c/misra/src/rules/RULE-21-16/MemcmpOnInappropriateEssentialTypeArgs.ql
@@ -1,13 +1,15 @@
 /**
  * @id c/misra/memcmp-on-inappropriate-essential-type-args
- * @name RULE-21-16: The pointer arguments to the Standard Library function memcmp shall point to either a pointer type,
+ * @name RULE-21-16: Do not use memcmp on pointers to characters or composite types such as structs and unions.
  * @description The pointer arguments to the Standard Library function memcmp shall point to either
  *              a pointer type, an essentially signed type, an essentially unsigned type, an
  *              essentially Boolean type or an essentially enum type
  * @kind problem
  * @precision very-high
  * @problem.severity error
  * @tags external/misra/id/rule-21-16
+ *       maintainability
+ *       correctness
  *       external/misra/obligation/required
  */
 
diff --git a/rule_packages/c/EssentialTypes.json b/rule_packages/c/EssentialTypes.json
@@ -6,22 +6,26 @@
       },
       "queries": [
         {
-          "description": "",
+          "description": "Using an inappropriate essential type operand may lead to confusing or unexpected behavior when the operand is converted.",
           "kind": "problem",
           "name": "Operands shall not be of an inappropriate essential type",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "OperandsOfAnInappropriateEssentialType",
-          "tags": []
+          "tags": [
+            "maintainability"
+          ]
         },
         {
-          "description": "",
+          "description": "Using pointer types with logical operators should be avoid because it can cause confusing behavior.",
           "kind": "problem",
           "name": "Logical operators should not be used with pointer types",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "PointerTypeOnLogicalOperator",
-          "tags": []
+          "tags": [
+            "correctness"
+          ]
         }
       ],
       "title": "Operands shall not be of an inappropriate essential type"
@@ -34,11 +38,14 @@
         {
           "description": "Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations",
           "kind": "problem",
-          "name": "Expressions of essentially character type shall not be used inappropriately in addition and",
+          "name": "Inappropriate use of essentially character type operands in addition and subtraction operations",
           "precision": "very-high",
           "severity": "error",
           "short_name": "AdditionSubtractionOnEssentiallyCharType",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations"
@@ -51,11 +58,14 @@
         {
           "description": "The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category",
           "kind": "problem",
-          "name": "The value of an expression shall not be assigned to an object with a narrower essential type or of a",
-          "precision": "high",
-          "severity": "error",
+          "name": "Do not assign to an object with a different essential type category or narrower essential type",
+          "precision": "very-high",
+          "severity": "warning",
           "short_name": "AssignmentOfIncompatibleEssentialType",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category"
@@ -68,11 +78,14 @@
         {
           "description": "Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category",
           "kind": "problem",
-          "name": "Both operands of an operator in which the usual arithmetic conversions are performed shall have the",
+          "name": "Operator with usual arithmetic conversions shall have operands with the same essential type category",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "OperandsWithMismatchedEssentialTypeCategory",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category"
@@ -83,13 +96,16 @@
       },
       "queries": [
         {
-          "description": "",
+          "description": "Casting the value of an expression to an inappropriate essential type may lead to confusing or unexpected behavior in the way the value is converted.",
           "kind": "problem",
           "name": "The value of an expression should not be cast to an inappropriate essential type",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "InappropriateEssentialTypeCast",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "The value of an expression should not be cast to an inappropriate essential type"
@@ -100,13 +116,16 @@
       },
       "queries": [
         {
-          "description": "",
+          "description": "Assigning a composite expression to an object with wider essential type can cause some unexpected conversions.",
           "kind": "problem",
           "name": "The value of a composite expression shall not be assigned to an object with wider essential type",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "AssignmentToWiderEssentialType",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "The value of a composite expression shall not be assigned to an object with wider essential type"
@@ -119,11 +138,14 @@
         {
           "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",
-          "name": "If a composite expression is used as one operand of an operator in which the usual arithmetic",
+          "name": "Implicit conversion of composite expression operand to wider essential type",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "ImplicitConversionOfCompositeExpression",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "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"
@@ -136,11 +158,14 @@
         {
           "description": "The value of a composite expression shall not be cast to a different essential type category or a wider essential type",
           "kind": "problem",
-          "name": "The value of a composite expression shall not be cast to a different essential type category or a",
+          "name": "Composite expression explicitly casted to wider or different essential type",
           "precision": "very-high",
-          "severity": "error",
+          "severity": "warning",
           "short_name": "InappropriateCastOfCompositeExpression",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "The value of a composite expression shall not be cast to a different essential type category or a wider essential type"
@@ -151,13 +176,16 @@
       },
       "queries": [
         {
-          "description": "",
+          "description": "A floating point loop counter can cause confusing behavior when incremented.",
           "kind": "problem",
           "name": "A loop counter shall not have essentially floating type",
-          "precision": "high",
-          "severity": "error",
+          "precision": "very-high",
+          "severity": "warning",
           "short_name": "LoopOverEssentiallyFloatType",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "A loop counter shall not have essentially floating type"
@@ -170,11 +198,14 @@
         {
           "description": "The pointer arguments to the Standard Library function memcmp shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type",
           "kind": "problem",
-          "name": "The pointer arguments to the Standard Library function memcmp shall point to either a pointer type,",
+          "name": "Do not use memcmp on pointers to characters or composite types such as structs and unions.",
           "precision": "very-high",
           "severity": "error",
           "short_name": "MemcmpOnInappropriateEssentialTypeArgs",
-          "tags": []
+          "tags": [
+            "maintainability",
+            "correctness"
+          ]
         }
       ],
       "title": "The pointer arguments to the Standard Library function memcmp shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type"
