Extend RustSizeDivergesFromC

Author: lucic71

cpp2rust/converter/converter_lib.cpp

@@ -339,6 +339,9 @@ bool RustSizeDivergesFromC(clang::QualType qt) {
   if (auto *arr = qt->getAsArrayTypeUnsafe()) {
     return RustSizeDivergesFromC(arr->getElementType());
   }
+  if (qt->isPointerType()) {
+    return true;
+  }
   return false;
 }
 

tests/ub/out/refcount/fd_use_after_close.rs

@@ -36,7 +36,9 @@ fn main_0() -> i32 {
         ((buf.as_pointer() as Ptr<i8>) as Ptr<i8>)
             .to_any()
             .reinterpret_cast::<u8>()
-            .with_slice_mut(4usize, |__buf| nix::unistd::read(__fd, __buf))
+            .with_slice_mut(::std::mem::size_of::<[i8; 4]>(), |__buf| {
+                nix::unistd::read(__fd, __buf)
+            })
     }) {
         Ok(__n) => __n as isize,
         Err(__e) => {

tests/unit/out/refcount/array_field_addr.rs

@@ -37,7 +37,7 @@ fn main_0() -> i32 {
     {
         ((array_field_ptr!(s, mask) as Ptr<u8>) as Ptr<u8>)
             .to_any()
-            .memset((5) as u8, 4usize as usize);
+            .memset((5) as u8, ::std::mem::size_of::<[u8; 4]>() as usize);
         ((array_field_ptr!(s, mask) as Ptr<u8>) as Ptr<u8>).to_any()
     };
     field!(s, after).write(2);
@@ -46,7 +46,7 @@ fn main_0() -> i32 {
     {
         ((out.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memcpy(
             &((array_field_ptr!(s, mask)) as Ptr<u8>).to_any(),
-            4usize as usize,
+            ::std::mem::size_of::<[u8; 4]>() as usize,
         );
         ((out.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any()
     };

tests/unit/out/refcount/bsearch_ptr_cmp.rs

@@ -24,7 +24,7 @@ fn main_0() -> i32 {
         let mut __found = AnyPtr::default();
         while __lo <= __hi && __found.is_null() {
             let __mid = __lo + (__hi - __lo) / 2;
-            let __elem = __base.offset(__mid as usize * 4usize);
+            let __elem = __base.offset(__mid as usize * ::std::mem::size_of::<i32>());
             let __r = int_cmp_0(
                 (((a1.as_pointer() as Ptr<i32>).offset(0)) as Ptr<i32>)
                     .to_any()

tests/unit/out/refcount/concepts.rs

@@ -7,7 +7,10 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 const _: () = assert!(true, "Small<int>");
-const _: () = assert!((4usize == 4_usize), "sizeof(int) == 4");
+const _: () = assert!(
+    (::std::mem::size_of::<i32>() == 4_usize),
+    "sizeof(int) == 4"
+);
 #[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(1)]
 pub struct Sized {}

tests/unit/out/refcount/destructor.rs

@@ -273,7 +273,8 @@ impl Templated_char_Impl for Ptr<Templated_char_> {
     fn destructor(&self) {
         global_0.with(|rc| {
             *rc.borrow_mut() = {
-                ((global_0.with(|rc| *rc.borrow()) as usize).wrapping_add((1usize as usize))) as i32
+                ((global_0.with(|rc| *rc.borrow()) as usize)
+                    .wrapping_add((::std::mem::size_of::<i8>() as usize))) as i32
             }
         });
     }
@@ -285,7 +286,8 @@ impl Templated_int_Impl for Ptr<Templated_int_> {
     fn destructor(&self) {
         global_0.with(|rc| {
             *rc.borrow_mut() = {
-                ((global_0.with(|rc| *rc.borrow()) as usize).wrapping_add((4usize as usize))) as i32
+                ((global_0.with(|rc| *rc.borrow()) as usize)
+                    .wrapping_add((::std::mem::size_of::<i32>() as usize))) as i32
             }
         });
     }

tests/unit/out/refcount/enum_underlying_type.rs

@@ -38,19 +38,19 @@ fn main_0() -> i32 {
     assert!(((b as i32) == (false as i32)));
     let mut s: Small = Small_SMALL_MAX;
     assert!(((s as i32) == 255));
-    assert!((1usize == 1_usize));
+    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!((8usize == 8_usize));
+    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!((2usize == 2_usize));
+    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));

tests/unit/out/refcount/fd_io.rs

@@ -70,15 +70,17 @@ fn main_0() -> i32 {
     {
         ((buf.as_pointer() as Ptr<i8>) as Ptr<i8>)
             .to_any()
-            .memset((0) as u8, 16usize as usize);
+            .memset((0) as u8, ::std::mem::size_of::<[i8; 16]>() as usize);
         ((buf.as_pointer() as Ptr<i8>) as Ptr<i8>).to_any()
     };
     assert!(
         (((match FdRegistry::with_fd(fd, |__fd| {
             ((buf.as_pointer() as Ptr<i8>) as Ptr<i8>)
                 .to_any()
                 .reinterpret_cast::<u8>()
-                .with_slice_mut(16usize, |__buf| nix::unistd::read(__fd, __buf))
+                .with_slice_mut(::std::mem::size_of::<[i8; 16]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
         }) {
             Ok(__n) => __n as isize,
             Err(__e) => {
@@ -110,7 +112,9 @@ fn main_0() -> i32 {
             ((buf.as_pointer() as Ptr<i8>) as Ptr<i8>)
                 .to_any()
                 .reinterpret_cast::<u8>()
-                .with_slice_mut(16usize, |__buf| nix::unistd::read(__fd, __buf))
+                .with_slice_mut(::std::mem::size_of::<[i8; 16]>(), |__buf| {
+                    nix::unistd::read(__fd, __buf)
+                })
         }) {
             Ok(__n) => __n as isize,
             Err(__e) => {

tests/unit/out/refcount/field_pointers.rs

@@ -171,7 +171,7 @@ fn main_0() -> i32 {
                     a
                 )) as Ptr<i32>)
                     .to_any(),
-                4usize as usize,
+                ::std::mem::size_of::<i32>() as usize,
             );
         ((field_ptr!(
             (array_field_ptr!(o.as_pointer(), items) as Ptr<Inner>).offset((2) as isize),
@@ -186,7 +186,7 @@ fn main_0() -> i32 {
                 a
             )) as Ptr<i32>)
                 .to_any(),
-            4usize as usize,
+            ::std::mem::size_of::<i32>() as usize,
         );
         ((y.as_pointer()) as Ptr<i32>).to_any()
     };