Add paren in ConvertUnsignedArithOperand

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3527,10 +3527,12 @@ void Converter::ConvertVarInit(clang::QualType qual_type, clang::Expr *expr) {
 
 void Converter::ConvertUnsignedArithOperand(clang::Expr *expr,
                                             clang::QualType type) {
+  bool needs_cast = (expr->isIntegerConstantExpr(ctx_) &&
+                     !clang::isa<clang::ImplicitCastExpr>(expr)) ||
+                    Mapper::Map(expr->getType()) != Mapper::Map(type);
+  PushParen paren(*this, needs_cast);
   Convert(expr);
-  if ((expr->isIntegerConstantExpr(ctx_) &&
-       !clang::isa<clang::ImplicitCastExpr>(expr)) ||
-      Mapper::Map(expr->getType()) != Mapper::Map(type)) {
+  if (needs_cast) {
     ConvertCast(type);
   }
 }

tests/unit/out/refcount/memcpy_struct_struct.rs

@@ -77,7 +77,8 @@ fn main_0() -> i32 {
             .to_any()
             .memcpy(
                 &(((table.as_pointer() as Ptr<Entry>).offset(0 as isize)) as Ptr<Entry>).to_any(),
-                (((*table_size.borrow()) as u64).wrapping_mul(::std::mem::size_of::<Entry>() as u64)
+                (((*table_size.borrow()) as u64)
+                    .wrapping_mul((::std::mem::size_of::<Entry>() as u64))
                     as usize) as usize,
             );
         (((table.as_pointer() as Ptr<Entry>).offset((*table_size.borrow()) as isize)) as Ptr<Entry>)

tests/unit/out/refcount/size_t_ssize_t.rs

@@ -39,23 +39,23 @@ fn main_0() -> i32 {
     assert!(!((*sz.borrow()) == ((*ul.borrow()) as usize)));
     let chain: Value<usize> = Rc::new(RefCell::new(
         (((((*sz.borrow()) as u64).wrapping_add((*ul.borrow()))).wrapping_add(5_u64))
-            .wrapping_add(::std::mem::size_of::<i64>() as u64) as usize),
+            .wrapping_add((::std::mem::size_of::<i64>() as u64)) as usize),
     ));
     assert!(
         ((*chain.borrow())
-            == (((20 + 10) + 5) as usize).wrapping_add(::std::mem::size_of::<i64>() as usize))
+            == (((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()) 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)
+            == ((((100_usize).wrapping_add((::std::mem::size_of::<f64>() as usize))) as usize)
                 .wrapping_mul(2_usize) as usize)
                 .wrapping_sub(10_usize))
     );
@@ -65,7 +65,7 @@ fn main_0() -> i32 {
     let fr: Value<usize> = Rc::new(RefCell::new(
         ({
             let _a: usize = ((::std::mem::size_of::<i32>() as u64)
-                .wrapping_add((*sz.borrow()) as u64) as usize);
+                .wrapping_add(((*sz.borrow()) as u64)) as usize);
             let _b: usize = ((*ul.borrow()) as usize);
             add_sizes_0(_a, _b)
         }),
@@ -99,7 +99,7 @@ fn main_0() -> i32 {
     let hi: Value<usize> = Rc::new(RefCell::new(
         ({
             let __tmp_0: Value<u64> = Rc::new(RefCell::new(
-                (::std::mem::size_of::<i32>() as u64).wrapping_add((*sz.borrow()) as u64),
+                (::std::mem::size_of::<i32>() as u64).wrapping_add(((*sz.borrow()) as u64)),
             ));
             (if __tmp_0.as_pointer().read() >= ul.as_pointer().read() {
                 __tmp_0.as_pointer()
@@ -129,7 +129,7 @@ fn main_0() -> i32 {
     ));
     let count: Value<usize> = Rc::new(RefCell::new(
         (::std::mem::size_of::<[i32; 8]>() as usize)
-            .wrapping_div(::std::mem::size_of::<i32>() as usize),
+            .wrapping_div((::std::mem::size_of::<i32>() as usize)),
     ));
     let i: Value<usize> = Rc::new(RefCell::new(0_usize));
     'loop_: while ((*i.borrow()) < (*count.borrow())) {
@@ -148,12 +148,12 @@ fn main_0() -> i32 {
     assert!(((*total.borrow()) == 56_usize));
     let cond: Value<usize> = Rc::new(RefCell::new(
         (if ((*sz.borrow()) > ((*ul.borrow()) as usize)) {
-            ((*sz.borrow()) as u64).wrapping_add(::std::mem::size_of::<i32>() as u64)
+            ((*sz.borrow()) as u64).wrapping_add((::std::mem::size_of::<i32>() as u64))
         } else {
             (*ul.borrow())
         } as usize),
     ));
-    assert!(((*cond.borrow()) == (21_usize).wrapping_add(::std::mem::size_of::<i32>() as usize)));
+    assert!(((*cond.borrow()) == (21_usize).wrapping_add((::std::mem::size_of::<i32>() as usize))));
     let arr: Value<Box<[usize]>> =
         Rc::new(RefCell::new(Box::new([0_usize, 1_usize, 2_usize, 3_usize])));
     let idx: Value<usize> = Rc::new(RefCell::new(

tests/unit/out/refcount/string_escape.rs

@@ -61,7 +61,7 @@ fn main_0() -> i32 {
     let i: Value<i32> = Rc::new(RefCell::new(0));
     'loop_: while ((*i.borrow())
         < (((::std::mem::size_of::<[u8; 41]>() as usize)
-            .wrapping_div(::std::mem::size_of::<u8>() as usize)) as i32))
+            .wrapping_div((::std::mem::size_of::<u8>() as usize))) as i32))
     {
         assert!({
             let _lhs = (((*special.borrow()).offset((*i.borrow()) as isize).read()) as i32);

tests/unit/out/refcount/types.rs

@@ -24,8 +24,8 @@ fn main_0() -> i32 {
     return ((((((((((((((*xu8.borrow()) as i32) + ((*xu16.borrow()) as i32)) as u32)
         .wrapping_add((*xu32.borrow()))) as u64)
         .wrapping_add((*xu64.borrow())))
-    .wrapping_add((*xsz1.borrow()) as u64))
-    .wrapping_add((*xsz2.borrow()) as u64))
+    .wrapping_add(((*xsz1.borrow()) as u64)))
+    .wrapping_add(((*xsz2.borrow()) as u64)))
     .wrapping_add(((*xi1.borrow()) as u64)))
     .wrapping_add(((*xi2.borrow()) as u64)))
     .wrapping_add(((*xi3.borrow()) as u64)))

tests/unit/out/unsafe/assign_as_value.rs

@@ -16,7 +16,7 @@ unsafe fn main_0() -> i32 {
     let mut p: *mut u8 = buf.as_mut_ptr();
     let mut q: *mut u8 = std::ptr::null_mut();
     q = {
-        p = (p).wrapping_add(1 as i32 as usize);
+        p = (p).wrapping_add((1 as i32) as usize);
         p
     };
     assert!(((((q) == (buf.as_mut_ptr().offset((1) as isize))) as i32) != 0));

tests/unit/out/unsafe/malloc_realloc_free.rs

@@ -19,9 +19,9 @@ unsafe fn main_0() -> i32 {
         (*p) = 42;
         assert!(((((*p) == (42)) as i32) != 0));
         libcc2rs::free_unsafe((p as *mut i32 as *mut ::libc::c_void));
-        let mut arr: *mut i32 =
-            (libcc2rs::malloc_unsafe((4_usize).wrapping_mul(::std::mem::size_of::<i32>() as usize))
-                as *mut i32);
+        let mut arr: *mut i32 = (libcc2rs::malloc_unsafe(
+            (4_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)),
+        ) as *mut i32);
         let mut i: i32 = 0;
         'loop_: while ((((i) < (4)) as i32) != 0) {
             (*arr.offset((i) as isize)) = ((i) * (10));
@@ -30,14 +30,14 @@ unsafe fn main_0() -> i32 {
         assert!(((((*arr.offset((0) as isize)) == (0)) as i32) != 0));
         assert!(((((*arr.offset((3) as isize)) == (30)) as i32) != 0));
         libcc2rs::free_unsafe((arr as *mut i32 as *mut ::libc::c_void));
-        let mut grow: *mut i32 =
-            (libcc2rs::malloc_unsafe((2_usize).wrapping_mul(::std::mem::size_of::<i32>() as usize))
-                as *mut i32);
+        let mut grow: *mut i32 = (libcc2rs::malloc_unsafe(
+            (2_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)),
+        ) as *mut i32);
         (*grow.offset((0) as isize)) = 1;
         (*grow.offset((1) as isize)) = 2;
         grow = (libcc2rs::realloc_unsafe(
             (grow as *mut i32 as *mut ::libc::c_void),
-            (4_usize).wrapping_mul(::std::mem::size_of::<i32>() as usize),
+            (4_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize)),
         ) as *mut i32);
         (*grow.offset((2) as isize)) = 3;
         (*grow.offset((3) as isize)) = 4;
@@ -76,7 +76,7 @@ unsafe fn main_0() -> i32 {
             (pfree).unwrap()(_arg0)
         });
         let mut arr: *mut i32 = ((unsafe {
-            let _arg0: usize = (4_usize).wrapping_mul(::std::mem::size_of::<i32>() as usize);
+            let _arg0: usize = (4_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize));
             (pmalloc).unwrap()(_arg0)
         }) as *mut i32);
         let mut i: i32 = 0;
@@ -91,14 +91,14 @@ unsafe fn main_0() -> i32 {
             (pfree).unwrap()(_arg0)
         });
         let mut grow: *mut i32 = ((unsafe {
-            let _arg0: usize = (2_usize).wrapping_mul(::std::mem::size_of::<i32>() as usize);
+            let _arg0: usize = (2_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize));
             (pmalloc).unwrap()(_arg0)
         }) as *mut i32);
         (*grow.offset((0) as isize)) = 1;
         (*grow.offset((1) as isize)) = 2;
         grow = ((unsafe {
             let _arg0: *mut ::libc::c_void = (grow as *mut i32 as *mut ::libc::c_void);
-            let _arg1: usize = (4_usize).wrapping_mul(::std::mem::size_of::<i32>() as usize);
+            let _arg1: usize = (4_usize).wrapping_mul((::std::mem::size_of::<i32>() as usize));
             (prealloc).unwrap()(_arg0, _arg1)
         }) as *mut i32);
         (*grow.offset((2) as isize)) = 3;

tests/unit/out/unsafe/memcpy_struct_struct.rs

@@ -54,11 +54,12 @@ unsafe fn main_0() -> i32 {
     ];
     let mut table_size: usize = 4_usize;
     {
-        if ((table_size as u64).wrapping_mul(::std::mem::size_of::<Entry>() as u64) as usize) != 0 {
+        if ((table_size as u64).wrapping_mul((::std::mem::size_of::<Entry>() as u64)) as usize) != 0
+        {
             ::std::ptr::copy_nonoverlapping(
                 ((&mut table[(0) as usize] as *mut Entry) as *const Entry as *const ::libc::c_void),
                 ((&mut table[(table_size)] as *mut Entry) as *mut Entry as *mut ::libc::c_void),
-                ((table_size as u64).wrapping_mul(::std::mem::size_of::<Entry>() as u64) as usize)
+                ((table_size as u64).wrapping_mul((::std::mem::size_of::<Entry>() as u64)) as usize)
                     as usize,
             )
         }

tests/unit/out/unsafe/pointer_usize_arith.rs

@@ -36,9 +36,9 @@ unsafe fn main_0() -> i32 {
     assert!(((*q2) == (10)));
     assert!(((q2) == (p)));
     let mut q3: *mut i32 = p;
-    q3 = (q3).wrapping_add(4 as i32 as usize);
+    q3 = (q3).wrapping_add((4 as i32) as usize);
     assert!(((*q3) == (14)));
-    q3 = (q3).wrapping_sub(2 as i32 as usize);
+    q3 = (q3).wrapping_sub((2 as i32) as usize);
     assert!(((*q3) == (12)));
     let mut step: usize = 2_usize;
     let mut q4: *mut i32 = p.offset((step) as isize);

tests/unit/out/unsafe/size_t_ssize_t.rs

@@ -31,26 +31,26 @@ unsafe fn main_0() -> i32 {
     assert!(((ul as usize) < (sz)));
     assert!(!((sz) == (ul as usize)));
     let mut chain: usize = ((((sz as u64).wrapping_add(ul)).wrapping_add(5_u64))
-        .wrapping_add(::std::mem::size_of::<i64>() as u64) as usize);
+        .wrapping_add((::std::mem::size_of::<i64>() as u64)) as usize);
     assert!(
         ((chain)
             == (((((20) + (10)) + (5)) as usize)
-                .wrapping_add(::std::mem::size_of::<i64>() as usize)))
+                .wrapping_add((::std::mem::size_of::<i64>() as usize))))
     );
     let mut acc: usize = 100_usize;
-    acc = ((acc as u64).wrapping_add(::std::mem::size_of::<f64>() as u64)) as usize;
+    acc = ((acc as u64).wrapping_add((::std::mem::size_of::<f64>() as u64))) as usize;
     acc = (acc).wrapping_mul(2_usize);
     acc = ((acc as u64).wrapping_sub(ul)) as usize;
     assert!(
         ((acc)
-            == (((((100_usize).wrapping_add(::std::mem::size_of::<f64>() as usize)) as usize)
+            == (((((100_usize).wrapping_add((::std::mem::size_of::<f64>() as usize))) as usize)
                 .wrapping_mul(2_usize) as usize)
                 .wrapping_sub(10_usize)))
     );
     sz = (sz).wrapping_add(1_usize);
     assert!(((sz) == (21_usize)));
     let mut fr: usize = (unsafe {
-        let _a: usize = ((::std::mem::size_of::<i32>() as u64).wrapping_add(sz as u64) as usize);
+        let _a: usize = ((::std::mem::size_of::<i32>() as u64).wrapping_add((sz as u64)) as usize);
         let _b: usize = (ul as usize);
         add_sizes_0(_a, _b)
     });
@@ -74,7 +74,7 @@ unsafe fn main_0() -> i32 {
         })
     } as usize);
     let mut hi: usize = ({
-        let mut __tmp_0 = (::std::mem::size_of::<i32>() as u64).wrapping_add(sz as u64);
+        let mut __tmp_0 = (::std::mem::size_of::<i32>() as u64).wrapping_add((sz as u64));
         (*if *&mut __tmp_0 >= *&mut ul {
             (&mut __tmp_0) as *const _
         } else {
@@ -95,7 +95,7 @@ unsafe fn main_0() -> i32 {
     assert!(((bound) == (4_usize)));
     let mut data: [i32; 8] = [0_i32; 8];
     let mut count: usize = (::std::mem::size_of::<[i32; 8]>() as usize)
-        .wrapping_div(::std::mem::size_of::<i32>() as usize);
+        .wrapping_div((::std::mem::size_of::<i32>() as usize));
     let mut i: usize = 0_usize;
     'loop_: while ((i) < (count)) {
         data[(i)] = (((i).wrapping_mul(2_usize)) as i32);
@@ -109,11 +109,11 @@ unsafe fn main_0() -> i32 {
     }
     assert!(((total) == (56_usize)));
     let mut cond: usize = (if ((sz) > (ul as usize)) {
-        (sz as u64).wrapping_add(::std::mem::size_of::<i32>() as u64)
+        (sz as u64).wrapping_add((::std::mem::size_of::<i32>() as u64))
     } else {
         ul
     } as usize);
-    assert!(((cond) == ((21_usize).wrapping_add(::std::mem::size_of::<i32>() as usize))));
+    assert!(((cond) == ((21_usize).wrapping_add((::std::mem::size_of::<i32>() as usize)))));
     let mut arr: [usize; 4] = [0_usize, 1_usize, 2_usize, 3_usize];
     let mut idx: usize = (if ((::std::mem::size_of::<i32>()) > (2_usize)) {
         2