Allow initialization of enums in global context (#64)

Previously, in C, enums were initialized with the `Enum::from(X as i32)`
pattern because enum variants are represented as int and the type of
variable is represented as enum.

The From trait is not allowed in global context because it's non-const.
This PR fixes this by short-circuiting `ConvertIntegerToEnumeralCast` to
emit `X` instead of `Enum::from(X as i32)`

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1733,6 +1733,19 @@ bool Converter::VisitCXXBoolLiteralExpr(clang::CXXBoolLiteralExpr *expr) {
 
 void Converter::ConvertIntegerToEnumeralCast(clang::Expr *to,
                                              clang::Expr *from) {
+  // Short circuit `Enum::from(X as i32)` to `X`
+  if (auto ref =
+          clang::dyn_cast<clang::DeclRefExpr>(from->IgnoreParenImpCasts())) {
+    if (auto ec = clang::dyn_cast<clang::EnumConstantDecl>(ref->getDecl())) {
+      auto src_enum = clang::dyn_cast<clang::EnumDecl>(ec->getDeclContext());
+      auto dst_enum = to->getType()->getAs<clang::EnumType>();
+      if (src_enum && dst_enum && dst_enum->getDecl() == src_enum) {
+        StrCat(std::format("{}::{}", GetRecordName(src_enum),
+                           std::string_view(ec->getName())));
+        return;
+      }
+    }
+  }
   StrCat(GetUnsafeTypeAsString(to->getType()), "::from");
   PushParen paren(*this);
   Convert(from);

tests/unit/enum_int_interop.cpp

@@ -15,6 +15,22 @@ typedef enum {
   TAG_TWO = 2,
 } Tag;
 
+struct Entry {
+  const char *name;
+  Color color;
+  Option opt;
+};
+
+static Color global_color = GREEN;
+static Option global_opt = OPT_B;
+static Tag global_tag = TAG_TWO;
+
+static Entry entries[3] = {
+    {"first", RED, OPT_NONE},
+    {"second", GREEN, OPT_A},
+    {"third", BLUE, OPT_C},
+};
+
 int as_int(Color c) { return c; }
 
 int classify_option(int option) {
@@ -113,5 +129,16 @@ int main() {
   int extra = (int)RED + (int)GREEN + (int)BLUE;
   assert(extra == 0 + 1 + 2);
 
+  assert(global_color == GREEN);
+  assert(global_opt == OPT_B);
+  assert(global_tag == TAG_TWO);
+
+  assert(entries[0].color == RED);
+  assert(entries[0].opt == OPT_NONE);
+  assert(entries[1].color == GREEN);
+  assert(entries[1].opt == OPT_A);
+  assert(entries[2].color == BLUE);
+  assert(entries[2].opt == OPT_C);
+
   return 0;
 }

tests/unit/enum_int_interop_c.c

@@ -15,6 +15,22 @@ typedef enum {
   TAG_TWO = 2,
 } Tag;
 
+struct Entry {
+  const char *name;
+  enum Color color;
+  enum Option opt;
+};
+
+static enum Color global_color = GREEN;
+static enum Option global_opt = OPT_B;
+static Tag global_tag = TAG_TWO;
+
+static struct Entry entries[3] = {
+    {"first", RED, OPT_NONE},
+    {"second", GREEN, OPT_A},
+    {"third", BLUE, OPT_C},
+};
+
 int as_int(enum Color c) { return c; }
 
 int classify_option(int option) {
@@ -113,5 +129,16 @@ int main() {
   int extra = (int)RED + (int)GREEN + (int)BLUE;
   assert(extra == 0 + 1 + 2);
 
+  assert(global_color == GREEN);
+  assert(global_opt == OPT_B);
+  assert(global_tag == TAG_TWO);
+
+  assert(entries[0].color == RED);
+  assert(entries[0].opt == OPT_NONE);
+  assert(entries[1].color == GREEN);
+  assert(entries[1].opt == OPT_A);
+  assert(entries[2].color == BLUE);
+  assert(entries[2].opt == OPT_C);
+
   return 0;
 }

tests/unit/out/refcount/anonymous_enum_c.rs

@@ -99,18 +99,18 @@ fn main_0() -> i32 {
     assert!(((((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)) as i32) != 0));
     assert!(((((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)) as i32) != 0));
     assert!(((((anon_enum_31::THIRD_A as i32) != (anon_enum_31::THIRD_B as i32)) as i32) != 0));
-    let td: Value<TdEnum> = Rc::new(RefCell::new(TdEnum::from((TdEnum::TD_A as i32))));
+    let td: Value<TdEnum> = Rc::new(RefCell::new(TdEnum::TD_A));
     assert!((((((*td.borrow()) as u32) == ((TdEnum::TD_A as i32) as u32)) as i32) != 0));
-    (*td.borrow_mut()) = TdEnum::from((TdEnum::TD_B as i32));
+    (*td.borrow_mut()) = TdEnum::TD_B;
     assert!((((((*td.borrow()) as u32) == ((TdEnum::TD_B as i32) as u32)) as i32) != 0));
     let w: Value<WithAnonField> = <Value<WithAnonField>>::default();
-    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::from((anon_enum_24::FIELD_A as i32));
+    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::FIELD_A;
     assert!(
         (((((*(*w.borrow()).field.borrow()) as u32) == ((anon_enum_24::FIELD_A as i32) as u32))
             as i32)
             != 0)
     );
-    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::from((anon_enum_24::FIELD_B as i32));
+    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::FIELD_B;
     assert!(
         (((((*(*w.borrow()).field.borrow()) as u32) == ((anon_enum_24::FIELD_B as i32) as u32))
             as i32)

tests/unit/out/refcount/bool_condition_enum_c.rs

@@ -27,8 +27,8 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let code: Value<Code> = Rc::new(RefCell::new(Code::from((Code::CODE_OK as i32))));
-    let err: Value<Code> = Rc::new(RefCell::new(Code::from((Code::CODE_ERR as i32))));
+    let code: Value<Code> = Rc::new(RefCell::new(Code::CODE_OK));
+    let err: Value<Code> = Rc::new(RefCell::new(Code::CODE_ERR));
     if ((*code.borrow()) != Code::from(0)) {
         assert!((0 != 0));
     }

tests/unit/out/refcount/bool_condition_logical_c.rs

@@ -47,7 +47,7 @@ fn main_0() -> i32 {
     let p: Value<Ptr<i32>> = Rc::new(RefCell::new((storage.as_pointer())));
     let np: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
     let u: Value<u32> = Rc::new(RefCell::new(4_u32));
-    let code: Value<Code> = Rc::new(RefCell::new(Code::from((Code::CODE_OK as i32))));
+    let code: Value<Code> = Rc::new(RefCell::new(Code::CODE_OK));
     if (((((*n.borrow()) != 0) && (!(*p.borrow()).is_null())) as i32) != 0) {
         assert!((1 != 0));
     }

tests/unit/out/refcount/c_struct.rs

@@ -96,7 +96,7 @@ fn main_0() -> i32 {
             a: Rc::new(RefCell::new(5)),
             b: Rc::new(RefCell::new(6)),
         })),
-        color: Rc::new(RefCell::new(Color::from((Color::GREEN as i32)))),
+        color: Rc::new(RefCell::new(Color::GREEN)),
         count: Rc::new(RefCell::new(42)),
     }));
     assert!(((((*(*(*c.borrow()).inner.borrow()).a.borrow()) == 5) as i32) != 0));
@@ -107,7 +107,7 @@ fn main_0() -> i32 {
     );
     assert!(((((*(*c.borrow()).count.borrow()) == 42) as i32) != 0));
     let c2: Value<Container> = <Value<Container>>::default();
-    (*(*c2.borrow()).color.borrow_mut()) = Color::from((Color::BLUE as i32));
+    (*(*c2.borrow()).color.borrow_mut()) = Color::BLUE;
     assert!((((((*(*c2.borrow()).color.borrow()) as u32) == 2_u32) as i32) != 0));
     return 0;
 }

tests/unit/out/refcount/enum_int_interop.rs

@@ -59,6 +59,51 @@ impl From<i32> for Tag {
         }
     }
 }
+#[derive(Default)]
+pub struct Entry {
+    pub name: Value<Ptr<u8>>,
+    pub color: Value<Color>,
+    pub opt: Value<Option>,
+}
+impl Clone for Entry {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            name: Rc::new(RefCell::new((*self.name.borrow()).clone())),
+            color: Rc::new(RefCell::new((*self.color.borrow()).clone())),
+            opt: Rc::new(RefCell::new((*self.opt.borrow()).clone())),
+        };
+        this
+    }
+}
+impl ByteRepr for Entry {}
+thread_local!(
+    pub static global_color: Value<Color> = Rc::new(RefCell::new(Color::GREEN));
+);
+thread_local!(
+    pub static global_opt: Value<Option> = Rc::new(RefCell::new(Option::OPT_B));
+);
+thread_local!(
+    pub static global_tag: Value<Tag> = Rc::new(RefCell::new(Tag::TAG_TWO));
+);
+thread_local!(
+    pub static entries: Value<Box<[Entry]>> = Rc::new(RefCell::new(Box::new([
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("first"))),
+            color: Rc::new(RefCell::new(Color::RED)),
+            opt: Rc::new(RefCell::new(Option::OPT_NONE)),
+        },
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("second"))),
+            color: Rc::new(RefCell::new(Color::GREEN)),
+            opt: Rc::new(RefCell::new(Option::OPT_A)),
+        },
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("third"))),
+            color: Rc::new(RefCell::new(Color::BLUE)),
+            opt: Rc::new(RefCell::new(Option::OPT_C)),
+        },
+    ])));
+);
 pub fn as_int_0(c: Color) -> i32 {
     let c: Value<Color> = Rc::new(RefCell::new(c));
     return ((*c.borrow()) as i32).clone();
@@ -183,5 +228,44 @@ fn main_0() -> i32 {
         (((Color::RED as i32) + (Color::GREEN as i32)) + (Color::BLUE as i32)),
     ));
     assert!(((*extra.borrow()) == ((0 + 1) + 2)));
+    assert!((((*global_color.with(Value::clone).borrow()) as i32) == (Color::GREEN as i32)));
+    assert!((((*global_opt.with(Value::clone).borrow()) as i32) == (Option::OPT_B as i32)));
+    assert!((((*global_tag.with(Value::clone).borrow()) as i32) == (Tag::TAG_TWO as i32)));
+    assert!(
+        (((*(*entries.with(Value::clone).borrow())[(0) as usize]
+            .color
+            .borrow()) as i32)
+            == (Color::RED as i32))
+    );
+    assert!(
+        (((*(*entries.with(Value::clone).borrow())[(0) as usize]
+            .opt
+            .borrow()) as i32)
+            == (Option::OPT_NONE as i32))
+    );
+    assert!(
+        (((*(*entries.with(Value::clone).borrow())[(1) as usize]
+            .color
+            .borrow()) as i32)
+            == (Color::GREEN as i32))
+    );
+    assert!(
+        (((*(*entries.with(Value::clone).borrow())[(1) as usize]
+            .opt
+            .borrow()) as i32)
+            == (Option::OPT_A as i32))
+    );
+    assert!(
+        (((*(*entries.with(Value::clone).borrow())[(2) as usize]
+            .color
+            .borrow()) as i32)
+            == (Color::BLUE as i32))
+    );
+    assert!(
+        (((*(*entries.with(Value::clone).borrow())[(2) as usize]
+            .opt
+            .borrow()) as i32)
+            == (Option::OPT_C as i32))
+    );
     return 0;
 }

tests/unit/out/refcount/enum_int_interop_c.rs

@@ -59,6 +59,41 @@ impl From<i32> for Tag {
         }
     }
 }
+#[derive(Default)]
+pub struct Entry {
+    pub name: Value<Ptr<u8>>,
+    pub color: Value<Color>,
+    pub opt: Value<Option>,
+}
+impl ByteRepr for Entry {}
+thread_local!(
+    pub static global_color: Value<Color> = Rc::new(RefCell::new(Color::GREEN));
+);
+thread_local!(
+    pub static global_opt: Value<Option> = Rc::new(RefCell::new(Option::OPT_B));
+);
+thread_local!(
+    pub static global_tag: Value<Tag> = Rc::new(RefCell::new(Tag::TAG_TWO));
+);
+thread_local!(
+    pub static entries: Value<Box<[Entry]>> = Rc::new(RefCell::new(Box::new([
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("first"))),
+            color: Rc::new(RefCell::new(Color::RED)),
+            opt: Rc::new(RefCell::new(Option::OPT_NONE)),
+        },
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("second"))),
+            color: Rc::new(RefCell::new(Color::GREEN)),
+            opt: Rc::new(RefCell::new(Option::OPT_A)),
+        },
+        Entry {
+            name: Rc::new(RefCell::new(Ptr::from_string_literal("third"))),
+            color: Rc::new(RefCell::new(Color::BLUE)),
+            opt: Rc::new(RefCell::new(Option::OPT_C)),
+        },
+    ])));
+);
 pub fn as_int_0(c: Color) -> i32 {
     let c: Value<Color> = Rc::new(RefCell::new(c));
     return ((*c.borrow()) as i32).clone();
@@ -95,7 +130,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let c: Value<Color> = Rc::new(RefCell::new(Color::from((Color::RED as i32))));
+    let c: Value<Color> = Rc::new(RefCell::new(Color::RED));
     assert!((((((*c.borrow()) as u32) == ((Color::RED as i32) as u32)) as i32) != 0));
     assert!((((((*c.borrow()) as u32) == 0_u32) as i32) != 0));
     assert!((((((*c.borrow()) as u32) != 1_u32) as i32) != 0));
@@ -137,7 +172,7 @@ fn main_0() -> i32 {
         (((*c.borrow()) as u32).wrapping_add(1_u32)) as i32,
     )));
     assert!((((((*cmp.borrow()) as u32) == ((Color::BLUE as i32) as u32)) as i32) != 0));
-    let o: Value<Option> = Rc::new(RefCell::new(Option::from((Option::OPT_A as i32))));
+    let o: Value<Option> = Rc::new(RefCell::new(Option::OPT_A));
     assert!((((((*o.borrow()) as u32) == ((Option::OPT_A as i32) as u32)) as i32) != 0));
     assert!((((((*o.borrow()) as u32) == 10_u32) as i32) != 0));
     let oi: Value<i32> = Rc::new(RefCell::new(((*o.borrow()) as i32).clone()));
@@ -161,7 +196,7 @@ fn main_0() -> i32 {
         classify_option_1(_option)
     });
     assert!(((((*rc.borrow()) == 3) as i32) != 0));
-    let t: Value<Tag> = Rc::new(RefCell::new(Tag::from((Tag::TAG_ONE as i32))));
+    let t: Value<Tag> = Rc::new(RefCell::new(Tag::TAG_ONE));
     assert!((((((*t.borrow()) as u32) == 1_u32) as i32) != 0));
     assert!((((((*t.borrow()) as u32) == ((Tag::TAG_ONE as i32) as u32)) as i32) != 0));
     let ti: Value<i32> = Rc::new(RefCell::new(((*t.borrow()) as i32).clone()));
@@ -187,5 +222,62 @@ fn main_0() -> i32 {
         (((Color::RED as i32) + (Color::GREEN as i32)) + (Color::BLUE as i32)),
     ));
     assert!(((((*extra.borrow()) == ((0 + 1) + 2)) as i32) != 0));
+    assert!(
+        (((((*global_color.with(Value::clone).borrow()) as u32) == ((Color::GREEN as i32) as u32))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((*global_opt.with(Value::clone).borrow()) as u32) == ((Option::OPT_B as i32) as u32))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((*global_tag.with(Value::clone).borrow()) as u32) == ((Tag::TAG_TWO as i32) as u32))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*entries.with(Value::clone).borrow())[(0) as usize]
+            .color
+            .borrow()) as u32)
+            == ((Color::RED as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*entries.with(Value::clone).borrow())[(0) as usize]
+            .opt
+            .borrow()) as u32)
+            == ((Option::OPT_NONE as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*entries.with(Value::clone).borrow())[(1) as usize]
+            .color
+            .borrow()) as u32)
+            == ((Color::GREEN as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*entries.with(Value::clone).borrow())[(1) as usize]
+            .opt
+            .borrow()) as u32)
+            == ((Option::OPT_A as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*entries.with(Value::clone).borrow())[(2) as usize]
+            .color
+            .borrow()) as u32)
+            == ((Color::BLUE as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*entries.with(Value::clone).borrow())[(2) as usize]
+            .opt
+            .borrow()) as u32)
+            == ((Option::OPT_C as i32) as u32)) as i32)
+            != 0)
+    );
     return 0;
 }