Emit bool values for enums with bool underlying type (#470)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -2482,6 +2482,12 @@ void Converter::ConvertIntegralToBooleanCast(clang::ImplicitCastExpr *expr) {
   auto sub_expr = expr->getSubExpr();
   auto *stripped = sub_expr->IgnoreParenImpCasts();
 
+  if (auto *enum_type = sub_expr->getType()->getAs<clang::EnumType>();
+      enum_type && enum_type->getDecl()->getIntegerType()->isBooleanType()) {
+    Convert(sub_expr);
+    return;
+  }
+
   if (auto binop = clang::dyn_cast<clang::BinaryOperator>(stripped)) {
     // Comparisons and logical ops already produces bool, no wrap needed.
     if ((binop->isComparisonOp() || binop->isLogicalOp()) &&
@@ -3847,11 +3853,16 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
   auto name = GetRecordName(decl);
   StrCat(std::format("pub type {} = {};", name,
                      GetUnsafeTypeAsString(decl->getIntegerType())));
+  bool is_bool = decl->getIntegerType()->isBooleanType();
   for (auto e : decl->enumerators()) {
     llvm::SmallVector<char, 32> init;
     e->getInitVal().toString(init, 10);
-    StrCat(std::format("pub const {}: {} = {};", EnumeratorName(e), name,
-                       std::string_view(init.data(), init.size())));
+    std::string value(init.data(), init.size());
+    if (is_bool) {
+      value = e->getInitVal().getBoolValue() ? "true" : "false";
+    }
+    StrCat(
+        std::format("pub const {}: {} = {};", EnumeratorName(e), name, value));
   }
   return false;
 }

tests/unit/enum_underlying_type.cpp

@@ -0,0 +1,49 @@
+#include <cassert>
+#include <cstdint>
+
+enum Flag : bool { FLAG_OFF = false, FLAG_ON = true };
+
+enum Small : unsigned char { SMALL_ZERO = 0, SMALL_MAX = 255 };
+
+enum Signed : signed char { SIGNED_MIN = -128, SIGNED_ONE = 1 };
+
+enum Wide : long long { WIDE_NEG = -1, WIDE_BIG = 1LL << 40 };
+
+enum Sized : uint16_t { SIZED_A = 1, SIZED_B = 0xFFFF };
+
+enum class Scoped : int8_t { NEG = -2, POS = 2 };
+
+int main() {
+  Flag flag = FLAG_ON;
+  assert(flag);
+  assert(!FLAG_OFF);
+  flag = FLAG_OFF;
+  assert(flag == FLAG_OFF);
+  bool b = flag;
+  assert(b == false);
+
+  Small s = SMALL_MAX;
+  assert(s == 255);
+  assert(sizeof(s) == 1);
+  s = SMALL_ZERO;
+  assert(s + 1 == 1);
+
+  Signed sg = SIGNED_MIN;
+  assert(sg == -128);
+  assert(sg < SIGNED_ONE);
+
+  Wide w = WIDE_BIG;
+  assert(w == (1LL << 40));
+  assert(sizeof(w) == 8);
+  assert(WIDE_NEG < 0);
+
+  Sized z = SIZED_B;
+  assert(z == 0xFFFF);
+  assert(sizeof(z) == 2);
+  assert(SIZED_A + 1 == 2);
+
+  Scoped sc = Scoped::NEG;
+  assert(static_cast<int>(sc) == -2);
+  assert(static_cast<int8_t>(Scoped::POS) == 2);
+  return 0;
+}

tests/unit/out/refcount/enum_underlying_type.rs

@@ -0,0 +1,60 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub type Flag = bool;
+pub const Flag_FLAG_OFF: Flag = false;
+pub const Flag_FLAG_ON: Flag = true;
+pub type Small = u8;
+pub const Small_SMALL_ZERO: Small = 0;
+pub const Small_SMALL_MAX: Small = 255;
+pub type Signed = i8;
+pub const Signed_SIGNED_MIN: Signed = -128;
+pub const Signed_SIGNED_ONE: Signed = 1;
+pub type Wide = i64;
+pub const Wide_WIDE_NEG: Wide = -1;
+pub const Wide_WIDE_BIG: Wide = 1099511627776;
+pub type Sized = u16;
+pub const Sized_SIZED_A: Sized = 1;
+pub const Sized_SIZED_B: Sized = 65535;
+pub type Scoped = i8;
+pub const Scoped_NEG: Scoped = -2;
+pub const Scoped_POS: Scoped = 2;
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let mut flag: Flag = Flag_FLAG_ON;
+    assert!(flag);
+    assert!(!(Flag_FLAG_OFF));
+    flag = Flag_FLAG_OFF;
+    assert!(((flag as i32) == (Flag_FLAG_OFF as i32)));
+    let mut b: bool = flag;
+    assert!(((b as i32) == (false as i32)));
+    let mut s: Small = Small_SMALL_MAX;
+    assert!(((s as i32) == 255));
+    assert!((::std::mem::size_of::<Small>() == 1_usize));
+    s = Small_SMALL_ZERO;
+    assert!((((s as i32) + 1) == 1));
+    let mut sg: Signed = Signed_SIGNED_MIN;
+    assert!(((sg as i32) == -128_i32));
+    assert!(((sg as i32) < (Signed_SIGNED_ONE as i32)));
+    let mut w: Wide = Wide_WIDE_BIG;
+    assert!(((w as i64) == (1_i64 << 40)));
+    assert!((::std::mem::size_of::<Wide>() == 8_usize));
+    assert!(((Wide_WIDE_NEG as i64) < 0_i64));
+    let mut z: Sized = Sized_SIZED_B;
+    assert!(((z as i32) == 65535));
+    assert!((::std::mem::size_of::<Sized>() == 2_usize));
+    assert!((((Sized_SIZED_A as i32) + 1) == 2));
+    let mut sc: Scoped = Scoped_NEG;
+    assert!(((sc as i32) == -2_i32));
+    assert!((((Scoped_POS as i8) as i32) == 2));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/enum_underlying_type.rs

@@ -0,0 +1,62 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub type Flag = bool;
+pub const Flag_FLAG_OFF: Flag = false;
+pub const Flag_FLAG_ON: Flag = true;
+pub type Small = u8;
+pub const Small_SMALL_ZERO: Small = 0;
+pub const Small_SMALL_MAX: Small = 255;
+pub type Signed = i8;
+pub const Signed_SIGNED_MIN: Signed = -128;
+pub const Signed_SIGNED_ONE: Signed = 1;
+pub type Wide = i64;
+pub const Wide_WIDE_NEG: Wide = -1;
+pub const Wide_WIDE_BIG: Wide = 1099511627776;
+pub type Sized = u16;
+pub const Sized_SIZED_A: Sized = 1;
+pub const Sized_SIZED_B: Sized = 65535;
+pub type Scoped = i8;
+pub const Scoped_NEG: Scoped = -2;
+pub const Scoped_POS: Scoped = 2;
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut flag: Flag = Flag_FLAG_ON;
+    assert!(flag);
+    assert!(!(Flag_FLAG_OFF));
+    flag = Flag_FLAG_OFF;
+    assert!(((flag as i32) == (Flag_FLAG_OFF as i32)));
+    let mut b: bool = flag;
+    assert!(((b as i32) == (false as i32)));
+    let mut s: Small = Small_SMALL_MAX;
+    assert!(((s as i32) == (255)));
+    assert!(((::std::mem::size_of::<Small>()) == (1_usize)));
+    s = Small_SMALL_ZERO;
+    assert!((((s as i32) + (1)) == (1)));
+    let mut sg: Signed = Signed_SIGNED_MIN;
+    assert!(((sg as i32) == (-128_i32)));
+    assert!(((sg as i32) < (Signed_SIGNED_ONE as i32)));
+    let mut w: Wide = Wide_WIDE_BIG;
+    assert!(((w as i64) == ((1_i64) << (40))));
+    assert!(((::std::mem::size_of::<Wide>()) == (8_usize)));
+    assert!(((Wide_WIDE_NEG as i64) < (0_i64)));
+    let mut z: Sized = Sized_SIZED_B;
+    assert!(((z as i32) == (65535)));
+    assert!(((::std::mem::size_of::<Sized>()) == (2_usize)));
+    assert!((((Sized_SIZED_A as i32) + (1)) == (2)));
+    let mut sc: Scoped = Scoped_NEG;
+    assert!(((sc as i32) == (-2_i32)));
+    assert!((((Scoped_POS as i8) as i32) == (2)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}