[Bug c++/97266] New: "enum constant in boolean context" warning seems incorrect

[Bug c++/97266] New: "enum constant in boolean context" warning seems incorrect

[mfarazma.ext at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

            Bug ID: 97266
           Summary: "enum constant in boolean context" warning seems
                    incorrect
           Product: gcc
           Version: 8.3.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: mfarazma.ext at gmail dot com
  Target Milestone: ---

```
#include <iostream>

enum ValidateFlag : int8_t {
   a = 0, b , c
};

int main(){ 
  bool t = static_cast<bool>(c);
  return static_cast<int>(t);
}
```

Compiling the above code with `g++ -Wall test.cc` generates this warning:

warning: enum constant in boolean context [-Wint-in-bool-context]

The behaviour doesn't seem correct as `c` is just an `int8_t` value, and
casting an `int8_t` value to `bool` does not generate any warnings:

```
  int8_t c = 2;         
  bool t = static_cast<bool>(c);
  return static_cast<int>(t);
```

Having only 2 values in the enum also makes it compile fine:
```
enum ValidateFlag : int8_t {
   a = 0, c
};
```

[Bug c++/97266] "enum constant in boolean context" warning seems incorrect

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

--- Comment #1 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to m farazma from comment #0)
> ```
> #include <iostream>
> 
> enum ValidateFlag : int8_t {
>    a = 0, b , c
> };
> 
> int main(){ 
>   bool t = static_cast<bool>(c);
>   return static_cast<int>(t);
> }
> ```
> 
> Compiling the above code with `g++ -Wall test.cc` generates this warning:
> 
> warning: enum constant in boolean context [-Wint-in-bool-context]
> 
> The behaviour doesn't seem correct as `c` is just an `int8_t` value,

No it isn't. In C enumerators are just integers, but in C++ they have the same
type as the enumeration type they belong to.

> and
> casting an `int8_t` value to `bool` does not generate any warnings:
> 
> ```
>   int8_t c = 2;         
>   bool t = static_cast<bool>(c);
>   return static_cast<int>(t);
> ```

I don't know why this is different. I would expect them to be consistent.


> Having only 2 values in the enum also makes it compile fine:
> ```
> enum ValidateFlag : int8_t {
>    a = 0, c
> };

In this case c=1 so there's no change in value when casting to bool. The
warning is for uses of integers other than 0 and 1.

[Bug c++/97266] "enum constant in boolean context" warning seems incorrect

[mfarazma.ext at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

--- Comment #2 from m farazma <mfarazma.ext at gmail dot com> ---
(In reply to Jonathan Wakely from comment #1)
> (In reply to m farazma from comment #0)
> > ```
> > #include <iostream>
> > 
> > enum ValidateFlag : int8_t {
> >    a = 0, b , c
> > };
> > 
> > int main(){ 
> >   bool t = static_cast<bool>(c);
> >   return static_cast<int>(t);
> > }
> > ```
> > 
> > Compiling the above code with `g++ -Wall test.cc` generates this warning:
> > 
> > warning: enum constant in boolean context [-Wint-in-bool-context]
> > 
> > The behaviour doesn't seem correct as `c` is just an `int8_t` value,
> 
> No it isn't. In C enumerators are just integers, but in C++ they have the
> same type as the enumeration type they belong to.
> 
But isn't the type of the enum set to be `int8_t` in this example?
In which case casting from `int8_t` to `bool` should be straight forward and
without warnings.

[Bug c++/97266] "enum constant in boolean context" warning seems incorrect

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

--- Comment #3 from Jonathan Wakely <redi at gcc dot gnu.org> ---
No, the type is ValidateFlag. It has an underlying type of int8_t, but that
just means it has the same size and range of values as int8_t. It's not
actually that type.

[Bug c++/97266] "enum constant in boolean context" warning seems incorrect

[mfarazma.ext at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

--- Comment #4 from m farazma <mfarazma.ext at gmail dot com> ---
(In reply to Jonathan Wakely from comment #3)
> No, the type is ValidateFlag. It has an underlying type of int8_t, but that
> just means it has the same size and range of values as int8_t. It's not
> actually that type.

Sorry for the confusion, I've tried creating a new variable with the following
2 types:

```
  ValidateFlag v = c;
  bool t = static_cast<bool>(v);
```

and

```
  int8_t i = c;
  bool t = static_cast<bool>(i);
```

and they both compile whiteout a warning, but using `c` itself causes the
issue.

[Bug c++/97266] "enum constant in boolean context" warning seems incorrect

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1
   Last reconfirmed|                            |2020-10-02

--- Comment #5 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Neither of those cases are constants, and the warning documentation (and the
actual diagnostic itself) talk about constants.

But there's still no warning for:

  constexpr ValidateFlag v = c;
  bool t = static_cast<bool>(v);

which definitely seems inconsistent. I don't know what the intended behaviour
is, but it should be consistent.

[Bug c++/97266] "enum constant in boolean context" warning seems incorrect

[mfarazma.ext at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97266

--- Comment #6 from m farazma <mfarazma.ext at gmail dot com> ---
(In reply to Jonathan Wakely from comment #5)
> Neither of those cases are constants, and the warning documentation (and the
> actual diagnostic itself) talk about constants.
> 
> But there's still no warning for:
> 
>   constexpr ValidateFlag v = c;
>   bool t = static_cast<bool>(v);
> 
> which definitely seems inconsistent. I don't know what the intended
> behaviour is, but it should be consistent.

When using clang 12 there are no warning messages. We had to 
use "-Wno-int-in-bool-context" to disable the warning on gcc.