Replace Ptr::delete_array with Ptr::delete

There's no need to catch all those UB cases; we can refine into working code.

Author: nunoplopes

cpp2rust/converter/models/converter_refcount.cpp

@@ -1878,7 +1878,7 @@ bool ConverterRefCount::VisitCXXNewExpr(clang::CXXNewExpr *expr) {
 bool ConverterRefCount::VisitCXXDeleteExpr(clang::CXXDeleteExpr *expr) {
   if (!TypeNeedsDestruction(expr->getDestroyedType())) {
     Convert(expr->getArgument());
-    StrCat(expr->isArrayForm() ? ".delete_array()" : ".delete()");
+    StrCat(".delete()");
     return false;
   }
 
@@ -1889,10 +1889,10 @@ bool ConverterRefCount::VisitCXXDeleteExpr(clang::CXXDeleteExpr *expr) {
     StrCat(std::format("for __i in 0..__p.len() {{ __p.offset(__i as "
                        "isize).{}(); }}",
                        kDestructorName));
-    StrCat("__p.delete_array()", token::kSemiColon);
+    StrCat("__p.delete();");
   } else {
-    StrCat(std::format("__p.{}()", kDestructorName), token::kSemiColon);
-    StrCat("__p.delete()", token::kSemiColon);
+    StrCat(std::format("__p.{}();", kDestructorName));
+    StrCat("__p.delete();");
   }
   return false;
 }

libcc2rs/src/alloc.rs

@@ -9,20 +9,20 @@ pub fn malloc_refcount(a0: usize) -> AnyPtr {
 }
 
 pub fn free_refcount(a0: AnyPtr) {
-    if a0.is_null() {
-        return;
+    if !a0.is_null() {
+        a0.reinterpret_cast::<u8>().delete();
     }
-    a0.reinterpret_cast::<u8>().delete_array();
 }
 
 pub fn realloc_refcount(a0: AnyPtr, a1: usize) -> AnyPtr {
     if a0.is_null() {
         return malloc_refcount(a1);
     }
     let __new = Ptr::alloc_array(vec![0u8; a1].into_boxed_slice()).to_any();
-    let __n = a1.min(a0.reinterpret_cast::<u8>().len());
+    let __src = a0.reinterpret_cast::<u8>();
+    let __n = a1.min(__src.len());
     __new.memcpy(&a0, __n);
-    a0.reinterpret_cast::<u8>().delete_array();
+    __src.delete();
     __new
 }
 

libcc2rs/src/rc.rs

@@ -220,25 +220,14 @@ impl<T> Ptr<T> {
     pub fn delete(&self) {
         match &self.kind {
             PtrKind::HeapSingle(weak) => {
-                assert_eq!(self.offset, 0, "ub: invalid delete");
                 assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
                 unsafe {
                     let strong = weak.upgrade().expect("ub: dangling pointer");
                     Rc::from_raw(Rc::as_ptr(&strong));
                 }
                 assert_eq!(Weak::strong_count(weak), 0, "ub: double free");
             }
-            PtrKind::Reinterpreted(data) => data.alloc.delete(),
-            PtrKind::Null => {}
-            _ => panic!("ub: invalid delete"),
-        }
-    }
-
-    #[inline]
-    pub fn delete_array(&self) {
-        match &self.kind {
             PtrKind::HeapArray(weak) => {
-                assert_eq!(self.offset, 0, "ub: invalid delete");
                 assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
                 unsafe {
                     let strong = weak.upgrade().expect("ub: dangling pointer");
@@ -247,7 +236,6 @@ impl<T> Ptr<T> {
                 assert_eq!(Weak::strong_count(weak), 0, "ub: double free");
             }
             PtrKind::HeapVec(weak) => {
-                assert_eq!(self.offset, 0, "ub: invalid delete");
                 assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
                 unsafe {
                     let strong = weak.upgrade().expect("ub: dangling pointer");
@@ -1025,31 +1013,31 @@ mod tests {
         let p: Ptr<Vec<i32>> = Ptr::alloc(vec![1, 2, 3]);
         let q = p.decay();
         assert_eq!(q.offset(2).read(), 3);
-        q.delete_array();
+        q.delete();
     }
 
     #[test]
     fn decay_heap_array_can_be_freed() {
         let p: Ptr<Box<[i32]>> = Ptr::alloc(vec![1, 2, 3].into_boxed_slice());
         let q = p.decay();
         assert_eq!(q.offset(2).read(), 3);
-        q.delete_array();
+        q.delete();
     }
 
     #[test]
     #[should_panic(expected = "ub: invalid delete")]
     fn decay_stack_vec_cannot_be_freed() {
         let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2, 3]));
         let p: Ptr<Vec<i32>> = v.as_pointer();
-        p.decay().delete_array();
+        p.decay().delete();
     }
 
     #[test]
     #[should_panic(expected = "ub: invalid delete")]
     fn decay_stack_array_cannot_be_freed() {
         let v: Value<Box<[i32]>> = Rc::new(RefCell::new(vec![1, 2, 3].into_boxed_slice()));
         let p: Ptr<Box<[i32]>> = (&v as &dyn AsPointer<Box<[i32]>>).as_pointer();
-        p.decay().delete_array();
+        p.decay().delete();
     }
 
     #[test]

rules/ifaddrs/tgt_refcount.rs

@@ -32,18 +32,9 @@ fn f2(a0: Ptr<Ifaddrs>) {
     let mut __cur = a0;
     while !__cur.is_null() {
         let __next = __cur.with(|__i| {
-            let __name = __i.ifa_name.borrow();
-            if !__name.is_null() {
-                __name.delete_array();
-            }
-            let __addr = __i.ifa_addr.borrow();
-            if !__addr.is_null() {
-                __addr.delete();
-            }
-            let __mask = __i.ifa_netmask.borrow();
-            if !__mask.is_null() {
-                __mask.delete();
-            }
+            __i.ifa_name.borrow().delete();
+            __i.ifa_addr.borrow().delete();
+            __i.ifa_netmask.borrow().delete();
             (*__i.ifa_next.borrow()).clone()
         });
         __cur.delete();

tests/ub/out/refcount/ub10.rs

@@ -18,7 +18,7 @@ fn main_0() -> i32 {
     )));
     let ptr: Value<Ptr<i32>> = Rc::new(RefCell::new((*arr.borrow()).offset((1) as isize)));
     let out: Value<i32> = Rc::new(RefCell::new(((*ptr.borrow()).read())));
-    (*ptr.borrow()).delete_array();
+    (*ptr.borrow()).delete();
     return (*out.borrow());
 }
 pub fn __cpp2rust_init_globals() {}

tests/ub/out/refcount/ub14.rs

@@ -17,7 +17,7 @@ fn main_0() -> i32 {
             .collect::<Box<[i32]>>(),
     )));
     (*arr1.borrow()).offset((100) as isize).write(1);
-    (*arr1.borrow()).delete_array();
+    (*arr1.borrow()).delete();
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/ub/out/refcount/ub15.rs

@@ -18,7 +18,7 @@ fn main_0() -> i32 {
     )));
     let ptr: Value<Ptr<i32>> = Rc::new(RefCell::new((*arr.borrow()).offset((15) as isize)));
     let out: Value<i32> = Rc::new(RefCell::new(((*ptr.borrow()).read())));
-    (*arr.borrow()).delete_array();
+    (*arr.borrow()).delete();
     return (*out.borrow());
 }
 pub fn __cpp2rust_init_globals() {}

tests/ub/out/refcount/ub16.rs

@@ -25,7 +25,7 @@ fn main_0() -> i32 {
             .offset((4) as isize)
             .read()),
     ));
-    (*p1.borrow()).delete_array();
+    (*p1.borrow()).delete();
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/ub/out/refcount/ub18.rs

@@ -13,7 +13,7 @@ pub fn main() {
 fn main_0() -> i32 {
     let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
     let p: Value<Ptr<i32>> = Rc::new(RefCell::new((arr.as_pointer() as Ptr<i32>)));
-    (*p.borrow()).delete_array();
+    (*p.borrow()).delete();
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/ub/out/refcount/ub19.rs

@@ -8,7 +8,7 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn foo_0(array: Ptr<i32>) {
     let array: Value<Ptr<i32>> = Rc::new(RefCell::new(array));
-    (*array.borrow()).delete_array();
+    (*array.borrow()).delete();
 }
 pub fn main() {
     __cpp2rust_init_globals();