Fix paren in compound assign

cpp2rust/converter/models/converter_refcount.cpp

@@ -1373,6 +1373,7 @@ void ConverterRefCount::ConvertBinaryOperator(clang::BinaryOperator *expr) {
       assign && GetSafeTypeAsString(lhs_type) !=
                     GetSafeTypeAsString(assign->getComputationResultType())) {
     auto computation_result_type = assign->getComputationResultType();
+    PushBrace brace(*this);
     StrCat(keyword::kLet, "rhs_0", token::kAssign);
     if (IsUnsignedArithOp(assign)) {
       PushParen outer(*this);
@@ -1405,6 +1406,7 @@ void ConverterRefCount::ConvertBinaryOperator(clang::BinaryOperator *expr) {
   }
 
   if (IsUnsignedArithOp(expr)) {
+    PushBrace brace(*this, expr->isCompoundAssignmentOp());
     if (expr->isCompoundAssignmentOp()) {
       StrCat(keyword::kLet, "rhs_0", token::kAssign);
     }

tests/unit/compound_assign_paren.cpp

@@ -0,0 +1,33 @@
+#include <assert.h>
+#include <stdint.h>
+
+#define SET_FLAG(s, f) ((s)->flags |= (f))
+#define CLEAR_FLAG(s, f) ((s)->flags &= (uint8_t)~(f))
+#define MARK_USED(bits, i) ((bits)[(i) / 8] |= (unsigned char)(1 << ((i) & 7)))
+
+struct Item {
+  uint8_t flags;
+};
+
+int main() {
+  Item item = {0};
+  Item *ptr = &item;
+  SET_FLAG(ptr, 1 << 0);
+  SET_FLAG(ptr, 1 << 1);
+  assert(ptr->flags == 3);
+  CLEAR_FLAG(ptr, 1 << 0);
+  assert(ptr->flags == 2);
+
+  unsigned char bits[4] = {0};
+  MARK_USED(bits, 5);
+  MARK_USED(bits, 13);
+  assert(bits[0] == 32);
+  assert(bits[1] == 32);
+  assert(bits[2] == 0);
+
+  if (ptr->flags != 0) {
+    CLEAR_FLAG(ptr, 1 << 1);
+  }
+  assert(ptr->flags == 0);
+  return 0;
+}

tests/unit/out/refcount/compound_assign_paren.rs

@@ -0,0 +1,87 @@
+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};
+#[derive(Default)]
+pub struct Item {
+    pub flags: Value<u8>,
+}
+impl Clone for Item {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            flags: Rc::new(RefCell::new((*self.flags.borrow()))),
+        };
+        this
+    }
+}
+impl ByteRepr for Item {
+    fn byte_size() -> usize {
+        1
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.flags.borrow()).to_bytes(&mut buf[0..1]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            flags: Rc::new(RefCell::new(<u8>::from_bytes(&buf[0..1]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let item: Value<Item> = Rc::new(RefCell::new(Item {
+        flags: Rc::new(RefCell::new(0_u8)),
+    }));
+    let ptr: Value<Ptr<Item>> = Rc::new(RefCell::new((item.as_pointer())));
+    ({
+        let rhs_0 =
+            (((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) | (1 << 0)) as u8;
+        (*(*(*ptr.borrow()).upgrade().deref()).flags.borrow_mut()) = rhs_0
+    });
+    ({
+        let rhs_0 =
+            (((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) | (1 << 1)) as u8;
+        (*(*(*ptr.borrow()).upgrade().deref()).flags.borrow_mut()) = rhs_0
+    });
+    assert!((((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) == 3));
+    ({
+        let rhs_0 = (((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32)
+            & ((!(1 << 0) as u8) as i32)) as u8;
+        (*(*(*ptr.borrow()).upgrade().deref()).flags.borrow_mut()) = rhs_0
+    });
+    assert!((((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) == 2));
+    let bits: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    ({
+        let rhs_0 = (((*bits.borrow())[((5) / 8) as usize] as i32)
+            | (((1 << ((5) & 7)) as u8) as i32)) as u8;
+        (*bits.borrow_mut())[((5) / 8) as usize] = rhs_0
+    });
+    ({
+        let rhs_0 = (((*bits.borrow())[((13) / 8) as usize] as i32)
+            | (((1 << ((13) & 7)) as u8) as i32)) as u8;
+        (*bits.borrow_mut())[((13) / 8) as usize] = rhs_0
+    });
+    assert!((((*bits.borrow())[(0) as usize] as i32) == 32));
+    assert!((((*bits.borrow())[(1) as usize] as i32) == 32));
+    assert!((((*bits.borrow())[(2) as usize] as i32) == 0));
+    if (((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) != 0) {
+        ({
+            let rhs_0 = (((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32)
+                & ((!(1 << 1) as u8) as i32)) as u8;
+            (*(*(*ptr.borrow()).upgrade().deref()).flags.borrow_mut()) = rhs_0
+        });
+    }
+    assert!((((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) == 0));
+    return 0;
+}

tests/unit/out/refcount/immutable_unsigned_arithmetic.rs

@@ -12,7 +12,9 @@ pub fn main() {
 fn main_0() -> i32 {
     let a: Value<u32> = Rc::new(RefCell::new(0_u32));
     let p: Value<Ptr<u32>> = Rc::new(RefCell::new((a.as_pointer())));
-    let rhs_0 = ((*p.borrow()).read()).wrapping_add(((*p.borrow()).read()));
-    (*p.borrow()).write(rhs_0);
+    {
+        let rhs_0 = ((*p.borrow()).read()).wrapping_add(((*p.borrow()).read()));
+        (*p.borrow()).write(rhs_0)
+    };
     return (((*p.borrow()).read()) as i32);
 }

tests/unit/out/refcount/size_t_ssize_t.rs

@@ -46,13 +46,19 @@ fn main_0() -> i32 {
             == (((20 + 10) + 5) as usize).wrapping_add((::std::mem::size_of::<i64>() as usize)))
     );
     let acc: Value<usize> = Rc::new(RefCell::new(100_usize));
-    let rhs_0 =
-        (((*acc.borrow()) as u64).wrapping_add((::std::mem::size_of::<f64>() as u64))) as usize;
-    (*acc.borrow_mut()) = rhs_0;
-    let rhs_0 = (*acc.borrow()).wrapping_mul(2_usize);
-    (*acc.borrow_mut()) = rhs_0;
-    let rhs_0 = (((*acc.borrow()) as u64).wrapping_sub((*ul.borrow()))) as usize;
-    (*acc.borrow_mut()) = rhs_0;
+    {
+        let rhs_0 =
+            (((*acc.borrow()) as u64).wrapping_add((::std::mem::size_of::<f64>() as u64))) as usize;
+        (*acc.borrow_mut()) = rhs_0
+    };
+    {
+        let rhs_0 = (*acc.borrow()).wrapping_mul(2_usize);
+        (*acc.borrow_mut()) = rhs_0
+    };
+    {
+        let rhs_0 = (((*acc.borrow()) as u64).wrapping_sub((*ul.borrow()))) as usize;
+        (*acc.borrow_mut()) = rhs_0
+    };
     assert!(
         ((*acc.borrow())
             == ((((100_usize).wrapping_add((::std::mem::size_of::<f64>() as usize))) as usize)
@@ -136,9 +142,11 @@ fn main_0() -> i32 {
     let total: Value<usize> = Rc::new(RefCell::new(0_usize));
     let i: Value<usize> = Rc::new(RefCell::new(0_usize));
     'loop_: while ((*i.borrow()) < (*count.borrow())) {
-        let rhs_0 =
-            (*total.borrow()).wrapping_add(((*data.borrow())[(*i.borrow()) as usize] as usize));
-        (*total.borrow_mut()) = rhs_0;
+        {
+            let rhs_0 =
+                (*total.borrow()).wrapping_add(((*data.borrow())[(*i.borrow()) as usize] as usize));
+            (*total.borrow_mut()) = rhs_0
+        };
         (*i.borrow_mut()).postfix_inc();
     }
     assert!(((*total.borrow()) == 56_usize));

tests/unit/out/unsafe/compound_assign_paren.rs

@@ -0,0 +1,40 @@
+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;
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Item {
+    pub flags: u8,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut item: Item = Item { flags: 0_u8 };
+    let mut ptr: *mut Item = (&mut item as *mut Item);
+    ((*(ptr)).flags = (((*(ptr)).flags as i32) | ((1) << (0))) as u8);
+    ((*(ptr)).flags = (((*(ptr)).flags as i32) | ((1) << (1))) as u8);
+    assert!((((*ptr).flags as i32) == (3)));
+    ((*(ptr)).flags = (((*(ptr)).flags as i32) & ((!((1) << (0)) as u8) as i32)) as u8);
+    assert!((((*ptr).flags as i32) == (2)));
+    let mut bits: [u8; 4] = [0_u8, 0_u8, 0_u8, 0_u8];
+    ((bits)[((5) / (8)) as usize] =
+        (((bits)[((5) / (8)) as usize] as i32) | ((((1) << ((5) & (7))) as u8) as i32)) as u8);
+    ((bits)[((13) / (8)) as usize] =
+        (((bits)[((13) / (8)) as usize] as i32) | ((((1) << ((13) & (7))) as u8) as i32)) as u8);
+    assert!(((bits[(0) as usize] as i32) == (32)));
+    assert!(((bits[(1) as usize] as i32) == (32)));
+    assert!(((bits[(2) as usize] as i32) == (0)));
+    if (((*ptr).flags as i32) != (0)) {
+        ((*(ptr)).flags = (((*(ptr)).flags as i32) & ((!((1) << (1)) as u8) as i32)) as u8);
+    }
+    assert!((((*ptr).flags as i32) == (0)));
+    return 0;
+}