Add extra as Ptr to avoid AsPointer ambiguity

Author: lucic71

cpp2rust/converter/models/converter_refcount.cpp

@@ -2371,6 +2371,12 @@ pub fn main() {{
 
 void ConverterRefCount::ConvertAddrOf(clang::Expr *expr,
                                       clang::QualType pointer_type) {
+  if (const auto *arr = ctx_.getAsArrayType(expr->getType())) {
+    PushConversionKind push(*this, ConversionKind::Unboxed);
+    StrCat(std::format("({} as Ptr<{}>)", ConvertPointer(expr),
+                       ToString(arr->getElementType())));
+    return;
+  }
   StrCat(ConvertPointer(expr));
 }
 

tests/unit/out/refcount/ptr_cast_init.rs

@@ -58,21 +58,72 @@ impl ByteRepr for view {
         }
     }
 }
+#[derive(Default)]
+pub struct entry {
+    pub id: Value<i32>,
+}
+impl Clone for entry {
+    fn clone(&self) -> Self {
+        Self {
+            id: Rc::new(RefCell::new((*self.id.borrow()).clone())),
+        }
+    }
+}
+impl ByteRepr for entry {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.id.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            id: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+thread_local!(
+    pub static e0_0: Value<entry> = Rc::new(RefCell::new(entry {
+        id: Rc::new(RefCell::new(1)),
+    }));
+);
+thread_local!(
+    pub static e1_1: Value<entry> = Rc::new(RefCell::new(entry {
+        id: Rc::new(RefCell::new(2)),
+    }));
+);
+thread_local!(
+    pub static registry_2: Value<Box<[Ptr<entry>]>> = Rc::new(RefCell::new(Box::new([
+        (e0_0.with(Value::clone).as_pointer()),
+        (e1_1.with(Value::clone).as_pointer()),
+        Ptr::<entry>::null(),
+    ])));
+);
+pub fn get_registry_3(out: Ptr<Ptr<Ptr<entry>>>) {
+    let out: Value<Ptr<Ptr<Ptr<entry>>>> = Rc::new(RefCell::new(out));
+    let __rhs = (registry_2.with(Value::clone).as_pointer() as Ptr<Ptr<entry>>)
+        .reinterpret_cast::<Ptr<entry>>();
+    (*out.borrow()).write(__rhs);
+}
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let text: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"hi\0")));
     let cp: Value<Ptr<u8>> = Rc::new(RefCell::new((text.as_pointer() as Ptr<u8>)));
-    let u: Value<Ptr<u8>> = Rc::new(RefCell::new((*cp.borrow()).reinterpret_cast::<u8>()));
+    let u: Value<Ptr<u8>> = Rc::new(RefCell::new(
+        ((*cp.borrow()).reinterpret_cast::<u8>()).clone(),
+    ));
     assert!(((((((*u.borrow()).offset((0) as isize).read()) as i32) == ('h' as i32)) as i32) != 0));
     assert!(((((((*u.borrow()).offset((1) as isize).read()) as i32) == ('i' as i32)) as i32) != 0));
     let h: Value<header> = Rc::new(RefCell::new(header {
         tag: Rc::new(RefCell::new(7)),
         size: Rc::new(RefCell::new(32)),
     }));
     let hp: Value<Ptr<header>> = Rc::new(RefCell::new((h.as_pointer())));
-    let v: Value<Ptr<view>> = Rc::new(RefCell::new((*hp.borrow()).reinterpret_cast::<view>()));
+    let v: Value<Ptr<view>> = Rc::new(RefCell::new(
+        ((*hp.borrow()).reinterpret_cast::<view>()).clone(),
+    ));
     assert!(((((*(*(*v.borrow()).upgrade().deref()).tag.borrow()) == 7) as i32) != 0));
     let data: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"hi\0")));
     let vp: Value<AnyPtr> = Rc::new(RefCell::new(
@@ -99,5 +150,27 @@ fn main_0() -> i32 {
     }
     .reinterpret_cast::<u8>();
     assert!(((((*sel.borrow()).is_null()) as i32) != 0));
+    let avail: Value<Ptr<Ptr<entry>>> = Rc::new(RefCell::new(Ptr::<Ptr<entry>>::null()));
+    ({ get_registry_3((avail.as_pointer())) });
+    assert!((((!((*avail.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((((*(*((*avail.borrow()).offset((0) as isize).read())
+            .upgrade()
+            .deref())
+        .id
+        .borrow())
+            == 1) as i32)
+            != 0)
+    );
+    assert!(
+        ((((*(*((*avail.borrow()).offset((1) as isize).read())
+            .upgrade()
+            .deref())
+        .id
+        .borrow())
+            == 2) as i32)
+            != 0)
+    );
+    assert!((((((*avail.borrow()).offset((2) as isize).read()).is_null()) as i32) != 0));
     return 0;
 }

tests/unit/out/refcount/union_cross_arm_cast.rs

@@ -207,15 +207,15 @@ fn main_0() -> i32 {
         .lo
         .borrow_mut()) = 8080_u16;
     assert!(
-        ((((((((*(*c.borrow()).u.borrow()).raw_().reinterpret_cast::<u8>())
+        ((((((((*(*c.borrow()).u.borrow()).raw_().reinterpret_cast::<u8>() as Ptr<u8>)
             .reinterpret_cast::<u8>())
         .offset((2) as isize)
         .read()) as i32)
             == 144) as i32)
             != 0)
     );
     assert!(
-        ((((((((*(*c.borrow()).u.borrow()).raw_().reinterpret_cast::<u8>())
+        ((((((((*(*c.borrow()).u.borrow()).raw_().reinterpret_cast::<u8>() as Ptr<u8>)
             .reinterpret_cast::<u8>())
         .offset((3) as isize)
         .read()) as i32)

tests/unit/out/refcount/union_memset_memcpy.rs

@@ -230,15 +230,17 @@ fn main_0() -> i32 {
     {
         (((*(*c.borrow()).view.borrow())
             .raw_()
-            .reinterpret_cast::<u8>()) as Ptr<u8>)
+            .reinterpret_cast::<u8>() as Ptr<u8>)
+            .clone() as Ptr<u8>)
             .to_any()
             .memcpy(
                 &((src.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
                 (*len.borrow()) as usize,
             );
         (((*(*c.borrow()).view.borrow())
             .raw_()
-            .reinterpret_cast::<u8>()) as Ptr<u8>)
+            .reinterpret_cast::<u8>() as Ptr<u8>)
+            .clone() as Ptr<u8>)
             .to_any()
             .clone()
     };

tests/unit/out/refcount/z_bit_cast.rs

@@ -21,7 +21,7 @@ fn main_0() -> i32 {
     ({ decay_cast_0(((a1.as_pointer() as Ptr<u32>).offset(0))) });
     ({ bit_cast_1(((a1.as_pointer() as Ptr<u32>) as Ptr<u32>).to_any()) });
     ({ bit_cast_1((((a1.as_pointer() as Ptr<u32>).offset(0)) as Ptr<u32>).to_any()) });
-    ({ bit_cast_1(((a1.as_pointer()) as Ptr<u32>).to_any()) });
+    ({ bit_cast_1(((a1.as_pointer() as Ptr<u32>) as Ptr<u32>).to_any()) });
     let ptr: Value<AnyPtr> = Rc::new(RefCell::new(
         ((a1.as_pointer() as Ptr<u32>) as Ptr<u32>).to_any(),
     ));

tests/unit/out/unsafe/ptr_cast_init.rs

@@ -17,6 +17,23 @@ pub struct header {
 pub struct view {
     pub tag: i32,
 }
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct entry {
+    pub id: i32,
+}
+pub static mut e0_0: entry = unsafe { entry { id: 1 } };
+pub static mut e1_1: entry = unsafe { entry { id: 2 } };
+pub static mut registry_2: [*const entry; 3] = unsafe {
+    [
+        (&raw const e0_0 as *const entry),
+        (&raw const e1_1 as *const entry),
+        std::ptr::null(),
+    ]
+};
+pub unsafe fn get_registry_3(mut out: *mut *mut *const entry) {
+    (*out) = ((&raw mut registry_2 as *mut [*const entry; 3]) as *mut *const entry);
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -50,5 +67,11 @@ unsafe fn main_0() -> i32 {
         (0 as *mut ::libc::c_void)
     } as *mut libc::c_char);
     assert!(((((sel).is_null()) as i32) != 0));
+    let mut avail: *mut *const entry = std::ptr::null_mut();
+    (unsafe { get_registry_3((&mut avail as *mut *mut *const entry)) });
+    assert!((((!((avail).is_null())) as i32) != 0));
+    assert!((((((*(*avail.offset((0) as isize))).id) == (1)) as i32) != 0));
+    assert!((((((*(*avail.offset((1) as isize))).id) == (2)) as i32) != 0));
+    assert!(((((*avail.offset((2) as isize)).is_null()) as i32) != 0));
     return 0;
 }

tests/unit/ptr_cast_init.c

@@ -10,6 +10,18 @@ struct view {
   int tag;
 };
 
+struct entry {
+  int id;
+};
+
+static const struct entry e0 = {1};
+static const struct entry e1 = {2};
+static const struct entry *registry[] = {&e0, &e1, NULL};
+
+static void get_registry(const struct entry ***out) {
+  *out = (const struct entry **)&registry;
+}
+
 int main(void) {
   const char text[] = "hi";
   const char *cp = text;
@@ -31,5 +43,13 @@ int main(void) {
   n = 200;
   sel = (n < 100) ? vp : NULL;
   assert(sel == 0);
+
+  const struct entry **avail = NULL;
+  get_registry(&avail);
+  assert(avail != NULL);
+  assert(avail[0]->id == 1);
+  assert(avail[1]->id == 2);
+  assert(avail[2] == NULL);
+
   return 0;
 }