# V2596\. MISRA\. The value of a composite expression should not be assigned to an object with wider essential type\.

This diagnostic rule is based on the [MISRA](https://www.misra.org.uk/) \(Motor Industry Software Reliability Association\) software development guidelines\.

This diagnostic rule is relevant only for C\.

The C language allows much flexibility in conversion between arithmetic types, but it also may lead to hidden problems such as loss of sign, loss of value, or loss of precision\.

The code example:

```cpp
void foo()
{
  ....
  uint16_t var_a = 30000;
  uint16_t var_b = 40000;
  uint32_t var_sum;
  var_sum = var_a + var_b;  /* var_sum = 70000 or 4464? */
  ....
}
```

When the `var_sum` variable value is evaluated, the `uint16_t` type is implicitly converted to `int`\. In consequence, the assignment result depends on the `int` type size:

* If `int` is 32 bit, the modulo `2^32` operation is performed, and the expected `70000` value is written to the `var_sum` variable\.
* If `int` is 16 bit, the modulo `2^16` operation is performed, and the `70000 % 65536 == 4464` value is be written to the `var_sum` variable\.

The MISRA C standard defines its own type model, called the [essential type model](https://pvs-studio.com/en/blog/terms/7007/)\.

Using the essential type model can help avoid many non\-obvious issues mentioned\. In particular, it discourages assigning composite expressions that have a narrower essential type to variables of a wider essential type, or passing such expressions to a function as an argument of a wider type\.

To fix the code above, use an explicit conversion to `uint32_t`:

```cpp
void foo()
{
  ....
  uint16_t var_a = 30 000;
  uint16_t var_b = 40 000;
  uint32_t var_sum;
  var_sum = (uint32_t)var_a + var_b;  /* var_sum = 70 000 */
  ....
};
```

Now the modulo `2^32` operation is performed in all cases, no matter what size the `int` type has, and the error does not occur even if `int` has the 16\-bit size\.