`M5-0-12`: Incorrect alerts on assignments of valid numerical values

[rvermeulen]

Affected rules

• M5-0-12

Description

This query reports false positives where an explicitly signed or unsigned char is implicilty converted to an explicitly unsigned or signed char.

This can occur when converting a value which is typed as signed/unsigned char. It can also occur in the expansion of a template parameter, as in this case integer literals will be fully converted to the desired type, which also causes false positives.

In addition, this query is currently only detecting assignments to variables. It should be expanded to detect implicit conversions from char to signed char or unsigned char - for example, in function call arguments.

Example

The following is compliant per example in the standard, however is still seen as a contravention.

void test() {
  unsigned char x = 10; // COMPLIANT
  unsigned char y = x; // COMPLIANT[FALSE_POSITIVE]
  // ...and similar for signed chars
}


template <typename T, T value>
class C1 {
  public:
    C1() : m_value(value) {} // COMPLIANT[FALSE_POSITIVE]
  private:
    T m_value;
};

void fp_test() {
  C1<std::uint8_t, 10> l1; 
  C1<std::uint8_t, 10U> l2;
}

template <typename T, T value>
class C2 {
  public:
    C2() : m_value(value) {} // NON_COMPLIANT
  private:
    T m_value;
};

void fp_test() {
  C2<std::uint8_t, 'A'> l1; 
}

[lcartey]

This query needs to be adjusted to report cases where a PlainCharType type is implicitly converted on assignment to a signed or unsigned char - note, it currently reports when a CharType is converted, which is incorrect because CharType includes the signed/unsigned types. e.g.:

  aexp.getUnspecifiedType() instanceof PlainCharType

The query currently only captures assignment into variables, but this does not cover the correct cases. Instead, we should modify the query to only look for Conversions that are implicit (explicit conversions are acceptable).