Translate sizeof pack (#328)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3205,6 +3205,14 @@ bool Converter::VisitTypeTraitExpr(clang::TypeTraitExpr *expr) {
   return false;
 }
 
+bool Converter::VisitSizeOfPackExpr(clang::SizeOfPackExpr *expr) {
+  clang::Expr::EvalResult result;
+  ENSURE(expr->EvaluateAsInt(result, ctx_));
+  StrCat(std::to_string(result.Val.getInt().getExtValue()));
+  computed_expr_type_ = ComputedExprType::FreshValue;
+  return false;
+}
+
 bool Converter::VisitOffsetOfExpr(clang::OffsetOfExpr *expr) {
   std::string member_path;
   for (unsigned i = 0; i < expr->getNumComponents(); ++i) {

cpp2rust/converter/converter.h

@@ -369,6 +369,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   VisitUnaryExprOrTypeTraitExpr(clang::UnaryExprOrTypeTraitExpr *expr);
 
   virtual bool VisitTypeTraitExpr(clang::TypeTraitExpr *expr);
+  virtual bool VisitSizeOfPackExpr(clang::SizeOfPackExpr *expr);
 
   virtual bool VisitOffsetOfExpr(clang::OffsetOfExpr *expr);
 

tests/unit/out/refcount/template_pack.rs

@@ -32,6 +32,31 @@ pub fn first_4(x: i32, args: i32) -> i32 {
     let args: Value<i32> = Rc::new(RefCell::new(args));
     return ((*x.borrow()) + ({ sum_2((*args.borrow())) }));
 }
+pub fn sizeof_pack_5() -> i32 {
+    return (0 as i32);
+}
+pub fn sizeof_pack_6(args: i32) -> i32 {
+    let args: Value<i32> = Rc::new(RefCell::new(args));
+    return (1 as i32);
+}
+pub fn sizeof_pack_7(args_0: i32, args_1: i32) -> i32 {
+    let args_0: Value<i32> = Rc::new(RefCell::new(args_0));
+    let args_1: Value<i32> = Rc::new(RefCell::new(args_1));
+    return (2 as i32);
+}
+pub fn sizeof_pack_8(args_0: i32, args_1: i32, args_2: i32) -> i32 {
+    let args_0: Value<i32> = Rc::new(RefCell::new(args_0));
+    let args_1: Value<i32> = Rc::new(RefCell::new(args_1));
+    let args_2: Value<i32> = Rc::new(RefCell::new(args_2));
+    return (3 as i32);
+}
+pub fn sizeof_pack_9(args_0: i32, args_1: i32, args_2: i32, args_3: i32) -> i32 {
+    let args_0: Value<i32> = Rc::new(RefCell::new(args_0));
+    let args_1: Value<i32> = Rc::new(RefCell::new(args_1));
+    let args_2: Value<i32> = Rc::new(RefCell::new(args_2));
+    let args_3: Value<i32> = Rc::new(RefCell::new(args_3));
+    return (4 as i32);
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -40,5 +65,10 @@ fn main_0() -> i32 {
     assert!((({ sum_1(4, 5,) }) == 9));
     assert!((({ first_3(10, 1, 2,) }) == 13));
     assert!((({ first_4(10, 0,) }) == 10));
+    assert!((({ sizeof_pack_5() }) == 0));
+    assert!((({ sizeof_pack_6(1,) }) == 1));
+    assert!((({ sizeof_pack_7(1, 2,) }) == 2));
+    assert!((({ sizeof_pack_8(1, 2, 3,) }) == 3));
+    assert!((({ sizeof_pack_9(1, 2, 3, 4,) }) == 4));
     return 0;
 }

tests/unit/out/unsafe/template_pack.rs

@@ -21,6 +21,26 @@ pub unsafe fn first_3(mut x: i32, mut args_1: i32, mut args_2: i32) -> i32 {
 pub unsafe fn first_4(mut x: i32, mut args: i32) -> i32 {
     return ((x) + (unsafe { sum_2(args) }));
 }
+pub unsafe fn sizeof_pack_5() -> i32 {
+    return (0 as i32);
+}
+pub unsafe fn sizeof_pack_6(mut args: i32) -> i32 {
+    return (1 as i32);
+}
+pub unsafe fn sizeof_pack_7(mut args_0: i32, mut args_1: i32) -> i32 {
+    return (2 as i32);
+}
+pub unsafe fn sizeof_pack_8(mut args_0: i32, mut args_1: i32, mut args_2: i32) -> i32 {
+    return (3 as i32);
+}
+pub unsafe fn sizeof_pack_9(
+    mut args_0: i32,
+    mut args_1: i32,
+    mut args_2: i32,
+    mut args_3: i32,
+) -> i32 {
+    return (4 as i32);
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -31,5 +51,10 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { sum_1(4, 5,) }) == (9)));
     assert!(((unsafe { first_3(10, 1, 2,) }) == (13)));
     assert!(((unsafe { first_4(10, 0,) }) == (10)));
+    assert!(((unsafe { sizeof_pack_5() }) == (0)));
+    assert!(((unsafe { sizeof_pack_6(1,) }) == (1)));
+    assert!(((unsafe { sizeof_pack_7(1, 2,) }) == (2)));
+    assert!(((unsafe { sizeof_pack_8(1, 2, 3,) }) == (3)));
+    assert!(((unsafe { sizeof_pack_9(1, 2, 3, 4,) }) == (4)));
     return 0;
 }

tests/unit/template_pack.cpp

@@ -6,10 +6,20 @@ template <typename T, typename... Args> T first(T x, Args... args) {
   return x + sum(args...);
 }
 
+template <typename... Args> int sizeof_pack(Args... args) {
+  return sizeof...(Args);
+}
+
 int main() {
   assert(sum(1, 2, 3) == 6);
   assert(sum(4, 5) == 9);
   assert(first(10, 1, 2) == 13);
   assert(first(10, 0) == 10);
+
+  assert(sizeof_pack() == 0);
+  assert(sizeof_pack(1) == 1);
+  assert(sizeof_pack(1, 2) == 2);
+  assert(sizeof_pack(1, 2, 3) == 3);
+  assert(sizeof_pack(1, 2, 3, 4) == 4);
   return 0;
 }