Add redundant copy in conversion test

Author: lucic71

tests/unit/out/refcount/redundant_copy_in_conversion.rs

@@ -0,0 +1,59 @@
+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 iter {
+    pub p: Value<Ptr<i32>>,
+}
+impl Clone for iter {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            p: Rc::new(RefCell::new((*self.p.borrow()).clone())),
+        };
+        this
+    }
+}
+impl ByteRepr for iter {}
+#[derive(Default)]
+pub struct const_iter {
+    pub p: Value<Ptr<i32>>,
+}
+impl const_iter {
+    pub fn const_iter(o: Ptr<iter>) -> Self {
+        let mut this = Self {
+            p: Rc::new(RefCell::new((*(*o.upgrade().deref()).p.borrow()).clone())),
+        };
+        this
+    }
+}
+impl Clone for const_iter {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            p: Rc::new(RefCell::new(Ptr::<i32>::null())),
+        };
+        this
+    }
+}
+impl ByteRepr for const_iter {}
+pub fn sink_0(i: const_iter) {
+    let i: Value<const_iter> = Rc::new(RefCell::new(i));
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let buf: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([0, 0])));
+    let it: Value<iter> = Rc::new(RefCell::new(iter {
+        p: Rc::new(RefCell::new((buf.as_pointer() as Ptr<i32>))),
+    }));
+    ({
+        let _i: const_iter = const_iter::const_iter(it.as_pointer());
+        sink_0(_i)
+    });
+    return 0;
+}

tests/unit/out/unsafe/redundant_copy_in_conversion.rs

@@ -0,0 +1,43 @@
+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 iter {
+    pub p: *mut i32,
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct const_iter {
+    pub p: *const i32,
+}
+impl const_iter {
+    pub unsafe fn const_iter(o: *const iter) -> Self {
+        let mut this = Self {
+            p: (*o).p.cast_const(),
+        };
+        this
+    }
+}
+pub unsafe fn sink_0(mut i: const_iter) {}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut buf: [i32; 2] = [0, 0];
+    let mut it: iter = iter {
+        p: buf.as_mut_ptr(),
+    };
+    (unsafe {
+        let _i: const_iter = const_iter::const_iter(&it as *const iter);
+        sink_0(_i)
+    });
+    return 0;
+}

tests/unit/redundant_copy_in_conversion.cpp

@@ -0,0 +1,20 @@
+struct iter {
+  using iterator_category = int;
+  int *p;
+};
+
+struct const_iter {
+  using iterator_category = int;
+  const int *p;
+  const_iter(const iter &o) : p(o.p) {}
+  const_iter(const const_iter &) = default;
+};
+
+static void sink(const_iter i) {}
+
+int main() {
+  int buf[2] = {0, 0};
+  iter it{buf};
+  sink(it);
+  return 0;
+}