[Sema] Use proper integral cast for an enumerate with a fixed bool type

[Mordante]

Summary

When casting an enumerate with a fixed bool type the casting should use an IntegralToBoolean instead of an IntegralCast.

Fixes PR47055: Incorrect codegen for enum with bool underlying type

[riccibruno]

clang/test/AST/ast-dump-enum-bool.cpp

2

Why a (pretty unreadable) json test? There is also make-ast-dump-check.sh to auto-generate an ast dump test.

[aaron.ballman]

clang/test/AST/ast-dump-enum-bool.cpp

2

I'd also like to see some CodeGen tests for various fixed underlying types that ensures the conversion to the underlying type happens before the conversion to the enumeration.

Also, at least one test showing this behaves properly with a C-style cast instead of a named cast.

[rsmith]

clang/test/AST/ast-dump-enum-bool.cpp

2

In addition to CodeGen tests, we should also test that constant evaluation does the right thing.

[Mordante]

clang/test/AST/ast-dump-enum-bool.cpp

2

@riccibruno Thanks for the hint! I wasn't aware of this tool. I've modified the AST test.

@aaron.ballman I've added a C-style AST test and CodeGen tests. However I'm not sure what you expect to see in the CodeGen tests. As I expected the CodeGen doesn't know about the enum, but it just uses the underlying type of the enum. Please let me know if you want to see additional tests.

[Mordante]

Addresses the review comments.

[rsmith]

clang/test/AST/ast-dump-enum-bool.cpp

1

I don't think we really need a dedicated AST test for this. Such tests create a maintenance burden, and they don't really capture what we care about here: that all non-zero values are correctly converted to the true value of the enumeration type.

clang/test/CodeGen/enum-bool.cpp

7–14

Some general guidance for writing IR testcases:

• Don't test things that aren't relevant to the test case; doing so will make the test brittle as IR generation changes. In particular, don't test the function attribute comments, the #0 introducing function metadata, instruction names, alignments.
• Use CHECK-LABEL for each function definition to improve matching semantics and diagnostics on mismatches. (The CHECK-LABELs are checked first, then the input is sliced up into pieces between them, and those pieces are checked independently.)
• Don't use CHECK-NEXT unless it's relevant to your test that no other instructions appear in between.

clang/test/SemaCXX/cxx2a-consteval.cpp

597–609

This DR test should go in test/CXX/drs/dr23xx.cpp, along with a suitable "magic comment" // dr2338: 12 to indicate this DR is implemented in Clang 12 onwards. (We have tooling that generates the clang.llvm.org/cxx_dr_status.html page from those magic comments.)

I don't think this has anything to do with consteval; a more-reduced test should work just as well (eg, static_assert((int)(E)2 == 1, "");) and would allow us to test this in C++11 onwards, not only in C++20.

[Mordante]

clang/test/AST/ast-dump-enum-bool.cpp

1

I'll remove the test.

clang/test/CodeGen/enum-bool.cpp

7–14

Thanks for the information, I'll reduce the test case.

clang/test/SemaCXX/cxx2a-consteval.cpp

597–609

I thought the magic comment could be done in any test file. It'll move the test and add the comment.

[Mordante]

Addresses review comments.

[aaron.ballman]

LGTM, thank you for the fix!

clang/lib/Sema/SemaCast.cpp

static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr,
   // floating-integral conversions. Again, only floating->enum is relevant.
   if (DestType->isEnumeralType()) {
     if (Self.RequireCompleteType(OpRange.getBegin(), DestType,
                                  diag::err_bad_cast_incomplete)) {
       SrcExpr = ExprError();
       return TC_Failed;
     }
     if (SrcType->isIntegralOrEnumerationType()) {
-      Kind = CK_IntegralCast;
+      // [expr.static.cast]p10 If the enumeration type has a fixed underlying
+      // type, the value is first converted to that type by integral conversion
+      const EnumType *Enum = DestType->getAs<EnumType>();
+      Kind = Enum->getDecl()->isFixed() &&
+                     Enum->getDecl()->getIntegerType()->isBooleanType()
+                 ? CK_IntegralToBoolean
+                 : CK_IntegralCast;
       return TC_Success;
     } else if (SrcType->isRealFloatingType())   {
       Kind = CK_FloatingToIntegral;
       return TC_Success;
     }
   }
 
   // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast.

clang/test/AST/ast-dump-enum-bool.cpp

+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown -fsyntax-only -ast-dump %s | FileCheck %s
+
+namespace dr2338 { // dr2338: yes
+namespace A {
+enum E { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+E b(int x) { return (E)x; }
+consteval E c(int x) { return (E)x; }
+} // namespace A
+namespace B {
+enum E : bool { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+E b(int x) { return (E)x; }
+consteval E c(int x) { return (E)x; }
+} // namespace B
+namespace C {
+enum class E { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+E b(int x) { return (E)x; }
+consteval E c(int x) { return (E)x; }
+} // namespace C
+namespace D {
+enum class E : bool { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+E b(int x) { return (E)x; }
+consteval E c(int x) { return (E)x; }
+} // namespace D
+} // namespace dr2338
+
+// CHECK:TranslationUnitDecl {{.*}} <<invalid sloc>> <invalid sloc>
+// CHECK:`-NamespaceDecl {{.*}} <{{.*}}ast-dump-enum-bool.cpp:3:1, line:28:1> line:3:11 dr2338
+// CHECK-NEXT:  |-NamespaceDecl {{.*}} <line:4:1, line:9:1> line:4:11 A
+// CHECK-NEXT:  | |-EnumDecl {{.*}} <line:5:1, col:20> col:6 referenced E
+// CHECK-NEXT:  | | |-EnumConstantDecl {{.*}} <col:10> col:10 Zero 'dr2338::A::E'
+// CHECK-NEXT:  | | `-EnumConstantDecl {{.*}} <col:16> col:16 One 'dr2338::A::E'
+// CHECK-NEXT:  | |-FunctionDecl {{.*}} <line:6:1, col:40> col:3 a 'dr2338::A::E (int)'
+// CHECK-NEXT:  | | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:  | | `-CompoundStmt {{.*}} <col:12, col:40>
+// CHECK-NEXT:  | |   `-ReturnStmt {{.*}} <col:14, col:37>
+// CHECK-NEXT:  | |     `-CXXStaticCastExpr {{.*}} <col:21, col:37> 'dr2338::A::E' static_cast<enum dr2338::A::E> <IntegralCast>
+// CHECK-NEXT:  | |       `-ImplicitCastExpr {{.*}} <col:36> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  | |         `-DeclRefExpr {{.*}} <col:36> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  | |-FunctionDecl {{.*}} <line:7:1, col:27> col:3 b 'dr2338::A::E (int)'
+// CHECK-NEXT:  | | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:  | | `-CompoundStmt {{.*}} <col:12, col:27>
+// CHECK-NEXT:  | |   `-ReturnStmt {{.*}} <col:14, col:24>
+// CHECK-NEXT:  | |     `-CStyleCastExpr {{.*}} <col:21, col:24> 'dr2338::A::E' <IntegralCast>
+// CHECK-NEXT:  | |       `-ImplicitCastExpr {{.*}} <col:24> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  | |         `-DeclRefExpr {{.*}} <col:24> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  | `-FunctionDecl {{.*}} <line:8:1, col:37> col:13 consteval c 'dr2338::A::E (int)'
+// CHECK-NEXT:  |   |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
+// CHECK-NEXT:  |   `-CompoundStmt {{.*}} <col:22, col:37>
+// CHECK-NEXT:  |     `-ReturnStmt {{.*}} <col:24, col:34>
+// CHECK-NEXT:  |       `-CStyleCastExpr {{.*}} <col:31, col:34> 'dr2338::A::E' <IntegralCast>
+// CHECK-NEXT:  |         `-ImplicitCastExpr {{.*}} <col:34> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  |           `-DeclRefExpr {{.*}} <col:34> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  |-NamespaceDecl {{.*}} <line:10:1, line:15:1> line:10:11 B
+// CHECK-NEXT:  | |-EnumDecl {{.*}} <line:11:1, col:27> col:6 referenced E 'bool'
+// CHECK-NEXT:  | | |-EnumConstantDecl {{.*}} <col:17> col:17 Zero 'dr2338::B::E'
+// CHECK-NEXT:  | | `-EnumConstantDecl {{.*}} <col:23> col:23 One 'dr2338::B::E'
+// CHECK-NEXT:  | |-FunctionDecl {{.*}} <line:12:1, col:40> col:3 a 'dr2338::B::E (int)'
+// CHECK-NEXT:  | | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:  | | `-CompoundStmt {{.*}} <col:12, col:40>
+// CHECK-NEXT:  | |   `-ReturnStmt {{.*}} <col:14, col:37>
+// CHECK-NEXT:  | |     `-CXXStaticCastExpr {{.*}} <col:21, col:37> 'dr2338::B::E' static_cast<enum dr2338::B::E> <IntegralToBoolean>
+// CHECK-NEXT:  | |       `-ImplicitCastExpr {{.*}} <col:36> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  | |         `-DeclRefExpr {{.*}} <col:36> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  | |-FunctionDecl {{.*}} <line:13:1, col:27> col:3 b 'dr2338::B::E (int)'
+// CHECK-NEXT:  | | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:  | | `-CompoundStmt {{.*}} <col:12, col:27>
+// CHECK-NEXT:  | |   `-ReturnStmt {{.*}} <col:14, col:24>
+// CHECK-NEXT:  | |     `-CStyleCastExpr {{.*}} <col:21, col:24> 'dr2338::B::E' <IntegralToBoolean>
+// CHECK-NEXT:  | |       `-ImplicitCastExpr {{.*}} <col:24> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  | |         `-DeclRefExpr {{.*}} <col:24> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  | `-FunctionDecl {{.*}} <line:14:1, col:37> col:13 consteval c 'dr2338::B::E (int)'
+// CHECK-NEXT:  |   |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
+// CHECK-NEXT:  |   `-CompoundStmt {{.*}} <col:22, col:37>
+// CHECK-NEXT:  |     `-ReturnStmt {{.*}} <col:24, col:34>
+// CHECK-NEXT:  |       `-CStyleCastExpr {{.*}} <col:31, col:34> 'dr2338::B::E' <IntegralToBoolean>
+// CHECK-NEXT:  |         `-ImplicitCastExpr {{.*}} <col:34> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  |           `-DeclRefExpr {{.*}} <col:34> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  |-NamespaceDecl {{.*}} <line:16:1, line:21:1> line:16:11 C
+// CHECK-NEXT:  | |-EnumDecl {{.*}} <line:17:1, col:26> col:12 referenced class E 'int'
+// CHECK-NEXT:  | | |-EnumConstantDecl {{.*}} <col:16> col:16 Zero 'dr2338::C::E'
+// CHECK-NEXT:  | | `-EnumConstantDecl {{.*}} <col:22> col:22 One 'dr2338::C::E'
+// CHECK-NEXT:  | |-FunctionDecl {{.*}} <line:18:1, col:40> col:3 a 'dr2338::C::E (int)'
+// CHECK-NEXT:  | | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:  | | `-CompoundStmt {{.*}} <col:12, col:40>
+// CHECK-NEXT:  | |   `-ReturnStmt {{.*}} <col:14, col:37>
+// CHECK-NEXT:  | |     `-CXXStaticCastExpr {{.*}} <col:21, col:37> 'dr2338::C::E' static_cast<enum dr2338::C::E> <IntegralCast>
+// CHECK-NEXT:  | |       `-ImplicitCastExpr {{.*}} <col:36> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  | |         `-DeclRefExpr {{.*}} <col:36> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  | |-FunctionDecl {{.*}} <line:19:1, col:27> col:3 b 'dr2338::C::E (int)'
+// CHECK-NEXT:  | | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:  | | `-CompoundStmt {{.*}} <col:12, col:27>
+// CHECK-NEXT:  | |   `-ReturnStmt {{.*}} <col:14, col:24>
+// CHECK-NEXT:  | |     `-CStyleCastExpr {{.*}} <col:21, col:24> 'dr2338::C::E' <IntegralCast>
+// CHECK-NEXT:  | |       `-ImplicitCastExpr {{.*}} <col:24> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  | |         `-DeclRefExpr {{.*}} <col:24> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  | `-FunctionDecl {{.*}} <line:20:1, col:37> col:13 consteval c 'dr2338::C::E (int)'
+// CHECK-NEXT:  |   |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
+// CHECK-NEXT:  |   `-CompoundStmt {{.*}} <col:22, col:37>
+// CHECK-NEXT:  |     `-ReturnStmt {{.*}} <col:24, col:34>
+// CHECK-NEXT:  |       `-CStyleCastExpr {{.*}} <col:31, col:34> 'dr2338::C::E' <IntegralCast>
+// CHECK-NEXT:  |         `-ImplicitCastExpr {{.*}} <col:34> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:  |           `-DeclRefExpr {{.*}} <col:34> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:  `-NamespaceDecl {{.*}} <line:22:1, line:27:1> line:22:11 D
+// CHECK-NEXT:    |-EnumDecl {{.*}} <line:23:1, col:33> col:12 referenced class E 'bool'
+// CHECK-NEXT:    | |-EnumConstantDecl {{.*}} <col:23> col:23 Zero 'dr2338::D::E'
+// CHECK-NEXT:    | `-EnumConstantDecl {{.*}} <col:29> col:29 One 'dr2338::D::E'
+// CHECK-NEXT:    |-FunctionDecl {{.*}} <line:24:1, col:40> col:3 a 'dr2338::D::E (int)'
+// CHECK-NEXT:    | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:    | `-CompoundStmt {{.*}} <col:12, col:40>
+// CHECK-NEXT:    |   `-ReturnStmt {{.*}} <col:14, col:37>
+// CHECK-NEXT:    |     `-CXXStaticCastExpr {{.*}} <col:21, col:37> 'dr2338::D::E' static_cast<enum dr2338::D::E> <IntegralToBoolean>
+// CHECK-NEXT:    |       `-ImplicitCastExpr {{.*}} <col:36> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:    |         `-DeclRefExpr {{.*}} <col:36> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:    |-FunctionDecl {{.*}} <line:25:1, col:27> col:3 b 'dr2338::D::E (int)'
+// CHECK-NEXT:    | |-ParmVarDecl {{.*}} <col:5, col:9> col:9 used x 'int'
+// CHECK-NEXT:    | `-CompoundStmt {{.*}} <col:12, col:27>
+// CHECK-NEXT:    |   `-ReturnStmt {{.*}} <col:14, col:24>
+// CHECK-NEXT:    |     `-CStyleCastExpr {{.*}} <col:21, col:24> 'dr2338::D::E' <IntegralToBoolean>
+// CHECK-NEXT:    |       `-ImplicitCastExpr {{.*}} <col:24> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:    |         `-DeclRefExpr {{.*}} <col:24> 'int' lvalue ParmVar {{.*}} 'x' 'int'
+// CHECK-NEXT:    `-FunctionDecl {{.*}} <line:26:1, col:37> col:13 consteval c 'dr2338::D::E (int)'
+// CHECK-NEXT:      |-ParmVarDecl {{.*}} <col:15, col:19> col:19 used x 'int'
+// CHECK-NEXT:      `-CompoundStmt {{.*}} <col:22, col:37>
+// CHECK-NEXT:        `-ReturnStmt {{.*}} <col:24, col:34>
+// CHECK-NEXT:          `-CStyleCastExpr {{.*}} <col:31, col:34> 'dr2338::D::E' <IntegralToBoolean>
+// CHECK-NEXT:            `-ImplicitCastExpr {{.*}} <col:34> 'int' <LValueToRValue> part_of_explicit_cast
+// CHECK-NEXT:              `-DeclRefExpr {{.*}} <col:34> 'int' lvalue ParmVar {{.*}} 'x' 'int'

clang/test/CodeGen/enum-bool.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s
+
+namespace dr2338 {
+namespace A {
+enum E { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define i32 @_ZN6dr23381A1aEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   ret i32 %0
+// CHECK-NEXT: }
+
+E b(int x) { return (E)x; }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define i32 @_ZN6dr23381A1bEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   ret i32 %0
+// CHECK-NEXT: }
+
+} // namespace A
+namespace B {
+enum E : bool { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define zeroext i1 @_ZN6dr23381B1aEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   %tobool = icmp ne i32 %0, 0
+// CHECK-NEXT:   ret i1 %tobool
+// CHECK-NEXT: }
+
+E b(int x) { return (E)x; }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define zeroext i1 @_ZN6dr23381B1bEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   %tobool = icmp ne i32 %0, 0
+// CHECK-NEXT:   ret i1 %tobool
+// CHECK-NEXT: }
+
+} // namespace B
+namespace C {
+enum class E { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define i32 @_ZN6dr23381C1aEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   ret i32 %0
+// CHECK-NEXT: }
+
+E b(int x) { return (E)x; }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define i32 @_ZN6dr23381C1bEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   ret i32 %0
+// CHECK-NEXT: }
+
+} // namespace C
+namespace D {
+enum class E : bool { Zero, One };
+E a(int x) { return static_cast<E>(x); }
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define zeroext i1 @_ZN6dr23381D1aEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   %tobool = icmp ne i32 %0, 0
+// CHECK-NEXT:   ret i1 %tobool
+// CHECK-NEXT: }
+
+E b(int x) { return (E)x; }
+
+// CHECK:      ; Function Attrs: noinline nounwind optnone
+// CHECK-NEXT: define zeroext i1 @_ZN6dr23381D1bEi(i32 %x) #0 {
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %x.addr = alloca i32, align 4
+// CHECK-NEXT:   store i32 %x, i32* %x.addr, align 4
+// CHECK-NEXT:   %0 = load i32, i32* %x.addr, align 4
+// CHECK-NEXT:   %tobool = icmp ne i32 %0, 0
+// CHECK-NEXT:   ret i1 %tobool
+
+} // namespace D
+} // namespace dr2338

clang/test/SemaCXX/cxx2a-consteval.cpp

void test() {
   { Copy* c; c = new Copy(std::move(C)); }
   { Copy* c; c = new Copy(std::move(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
   { Copy* c; c = new Copy(to_lvalue_ref(Copy(&f_eval))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
   { Copy* c; c = new Copy(to_lvalue_ref(std::move(C))); }
   { Copy* c; c = new Copy(to_lvalue_ref(std::move(Copy(&f_eval)))); }// expected-error {{is not a constant expression}} expected-note {{to a consteval}}
 }
 
 } // namespace special_ctor
+
+namespace dr2338 {
+namespace B {
+enum E : bool { Zero, One };
+consteval E c(int x) { return (E)x; }
+static_assert(static_cast<int>(c(2)) == 1);
+} // namespace B
+namespace D {
+enum class E : bool { Zero, One };
+consteval E c(int x) { return (E)x; }
+static_assert(static_cast<int>(c(2)) == 1);
+} // namespace D
+} // namespace dr2338