"case value is not a constant expression" casting an enum to an integer

[berolinux]

This code (extracted from systemtap 5.4) builds fine with g++ 15.2, but errors out with clang++ 21.1.5:

enum a {
        b
};

const a c = (a) -1;

int main(int argc, char **argv) {
        int d;
        switch(d) {
        case c:
                break;
        }
}

clang's complaint is

test.cpp:10:7: error: case value is not a constant expression
   10 |         case c:
      |              ^
test.cpp:10:7: note: initializer of 'c' is not a constant expression
test.cpp:5:9: note: declared here
    5 | const a c = (a) -1;
      |         ^
1 error generated.

Not 100% sure which compiler is doing the right thing here; the problem persists if I change const a c = (a) -1; to constexpr a c = (a) -1; (gcc still compiles it without even throwing a warning about it, even with -Wall -Wextra).

Both compilers are set up to use -std=c++20.

Making it even more obvious with constexpr a c = static_cast<a>(static_cast<unsigned>(-1)); results in another situation where gcc and clang disagree:

clang:

test.cpp:5:13: error: constexpr variable 'c' must be initialized by a constant expression
    5 | constexpr a c = static_cast<a>(static_cast<unsigned>(-1));
      |             ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test.cpp:5:17: note: integer value 4294967295 is outside the valid range of values [0, 1] for the enumeration type 'a'
    5 | constexpr a c = static_cast<a>(static_cast<unsigned>(-1));
      |                 ^
test.cpp:10:7: error: case value is not a constant expression
   10 |         case c:
      |              ^
test.cpp:10:7: note: initializer of 'c' is not a constant expression
test.cpp:5:13: note: declared here
    5 | constexpr a c = static_cast<a>(static_cast<unsigned>(-1));
      |             ^
2 errors generated.

gcc still compiles it without complaining about anything.
Again not sure what the standard says about this, clang's error certainly looks reasonable in this case (but I'd think gcc is right in the constexpr a c = (a) -1; case).

[berolinux]

Checking the standard, I'd argue gcc's behavior of accepting the code is correct and this is a clang bug.

(a)-1 is a core constant expression.
Integer-to-enum conversion is permitted in constant expressions even if the resulting value is not one of the enumerators.
(C++23: [expr.const]/[dcl.enum]/[conv.integral])

a is a literal type, and a const object of literal type with static storage duration initialized by a constant expression is an integral constant expression.
(C++23: [expr.const]/[expr.const]/5)

A case label requires an integral constant expression, which c meets.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Bernhard Rosenkraenzer (berolinux)

This code (extracted from systemtap 5.4) builds fine with g++ 15.2, but errors out with clang++ 21.1.5:

enum a {
        b
};

const a c = (a) -1;

int main(int argc, char **argv) {
        int d;
        switch(d) {
        case c:
                break;
        }
}

clang's complaint is

test.cpp:10:7: error: case value is not a constant expression
   10 |         case c:
      |              ^
test.cpp:10:7: note: initializer of 'c' is not a constant expression
test.cpp:5:9: note: declared here
    5 | const a c = (a) -1;
      |         ^
1 error generated.

Not 100% sure which compiler is doing the right thing here; the problem persists if I change const a c = (a) -1; to constexpr a c = (a) -1; (gcc still compiles it without even throwing a warning about it, even with -Wall -Wextra).

Both compilers are set up to use -std=c++20.

Making it even more obvious with constexpr a c = static_cast<a>(static_cast<unsigned>(-1)); results in another situation where gcc and clang disagree:

clang:

test.cpp:5:13: error: constexpr variable 'c' must be initialized by a constant expression
    5 | constexpr a c = static_cast<a>(static_cast<unsigned>(-1));
      |             ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test.cpp:5:17: note: integer value 4294967295 is outside the valid range of values [0, 1] for the enumeration type 'a'
    5 | constexpr a c = static_cast<a>(static_cast<unsigned>(-1));
      |                 ^
test.cpp:10:7: error: case value is not a constant expression
   10 |         case c:
      |              ^
test.cpp:10:7: note: initializer of 'c' is not a constant expression
test.cpp:5:13: note: declared here
    5 | constexpr a c = static_cast<a>(static_cast<unsigned>(-1));
      |             ^
2 errors generated.

gcc still compiles it without complaining about anything.
Again not sure what the standard says about this, clang's error certainly looks reasonable in this case (but I'd think gcc is right in the constexpr a c = (a) -1; case).

[shafik]

Clang is correct here, although the diagnostic in the non-constantexpr case is underwhelming. This is exor.static.cast p8:

... If the enumeration type does not have a fixed underlying type, the value is unchanged if the original value is within the range of the enumeration values ([dcl.enum]), and otherwise, the behavior is undefined. ...

We can see if we give the enum a fixed underlying type the problem goes away: https://godbolt.org/z/xhTsh75TE

enum a : int { b };

There are a number of reasonable fixes, including expanding the range of enumerators.

[frederick-vs-ja]

This is CWG1766. Clang has implemented the resolution and then correctly rejects such conversion in constant evaluation. IIUC, GCC hasn't implemented the resolution yet.

[AaronBallman]

Closing this issue as Clang's behavior is correct.