Add implicit autoref tests

Author: lucic71

tests/unit/implicit_autoref.cpp

@@ -0,0 +1,36 @@
+#include <cstdio>
+
+struct Counter {
+  int value = 0;
+  void bump() { ++value; }
+  int get() const { return value; }
+};
+
+struct Holder {
+  Counter c;
+  Counter &ref;
+  Holder(Counter &c) : ref(c) {}
+};
+
+void via_ref(Counter &r) { r.bump(); }
+
+int main() {
+  Counter c;
+  Counter *p = &c;
+  (*p).bump();
+  p->bump();
+
+  Counter arr[2];
+  arr[0].bump();
+  arr[1].bump();
+
+  Holder h(c);
+  h.c.bump();
+  h.ref.bump();
+
+  via_ref(c);
+
+  int sum = (*p).get() + h.c.get() + h.ref.get() + arr[0].get() + arr[1].get();
+  printf("%d\n", sum);
+  return 0;
+}

tests/unit/out/refcount/implicit_autoref.rs

@@ -0,0 +1,94 @@
+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 Counter {
+    pub value: Value<i32>,
+}
+impl Counter {
+    pub fn bump(&self) {
+        (*self.value.borrow_mut()).prefix_inc();
+    }
+    pub fn get(&self) -> i32 {
+        return (*self.value.borrow());
+    }
+}
+impl Clone for Counter {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            value: Rc::new(RefCell::new((*self.value.borrow()))),
+        };
+        this
+    }
+}
+impl ByteRepr for Counter {}
+#[derive(Default)]
+pub struct Holder {
+    pub c: Value<Counter>,
+    pub ref_: Ptr<Counter>,
+}
+impl Holder {
+    pub fn Holder(c: Ptr<Counter>) -> Self {
+        let mut this = Self {
+            c: Rc::new(RefCell::new(<Counter>::default())),
+            ref_: (c).clone(),
+        };
+        this
+    }
+}
+impl Clone for Holder {
+    fn clone(&self) -> Self {
+        let mut this = Self {
+            c: Rc::new(RefCell::new((*self.c.borrow()).clone())),
+            ref_: (self.ref_).clone(),
+        };
+        this
+    }
+}
+impl ByteRepr for Holder {}
+pub fn via_ref_0(r: Ptr<Counter>) {
+    ({ (*r.upgrade().deref()).bump() });
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Counter> = Rc::new(RefCell::new(<Counter>::default()));
+    let p: Value<Ptr<Counter>> = Rc::new(RefCell::new((c.as_pointer())));
+    ({ (*(*p.borrow()).upgrade().deref()).bump() });
+    ({ (*(*p.borrow()).upgrade().deref()).bump() });
+    let arr: Value<Box<[Counter]>> = Rc::new(RefCell::new(
+        (0..2)
+            .map(|_| <Counter>::default())
+            .collect::<Box<[Counter]>>(),
+    ));
+    ({ (*arr.borrow())[(0) as usize].bump() });
+    ({ (*arr.borrow())[(1) as usize].bump() });
+    let h: Value<Holder> = Rc::new(RefCell::new(Holder::Holder(c.as_pointer())));
+    ({ (*(*h.borrow()).c.borrow()).bump() });
+    ({ (*(*h.borrow()).ref_.upgrade().deref()).bump() });
+    ({
+        let _r: Ptr<Counter> = c.as_pointer();
+        via_ref_0(_r)
+    });
+    let sum: Value<i32> = Rc::new(RefCell::new({
+        let _lhs = {
+            let _lhs = {
+                let _lhs = {
+                    let _lhs = ({ (*(*p.borrow()).upgrade().deref()).get() });
+                    _lhs + ({ (*(*h.borrow()).c.borrow()).get() })
+                };
+                _lhs + ({ (*(*h.borrow()).ref_.upgrade().deref()).get() })
+            };
+            _lhs + ({ (*arr.borrow())[(0) as usize].get() })
+        };
+        _lhs + ({ (*arr.borrow())[(1) as usize].get() })
+    }));
+    println!("{}", (*sum.borrow()));
+    return 0;
+}

tests/unit/out/unsafe/implicit_autoref.rs

@@ -0,0 +1,66 @@
+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 Counter {
+    pub value: i32,
+}
+impl Counter {
+    pub unsafe fn bump(&mut self) {
+        self.value.prefix_inc();
+    }
+    pub unsafe fn get(&self) -> i32 {
+        return self.value;
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Holder {
+    pub c: Counter,
+    pub ref_: *mut Counter,
+}
+impl Holder {
+    pub unsafe fn Holder(c: *mut Counter) -> Self {
+        let mut this = Self {
+            c: <Counter>::default(),
+            ref_: c,
+        };
+        this
+    }
+}
+pub unsafe fn via_ref_0(r: *mut Counter) {
+    (unsafe { (*r).bump() });
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut c: Counter = <Counter>::default();
+    let mut p: *mut Counter = (&mut c as *mut Counter);
+    (unsafe { (*p).bump() });
+    (unsafe { (*p).bump() });
+    let mut arr: [Counter; 2] = [<Counter>::default(); 2];
+    (unsafe { arr[(0) as usize].bump() });
+    (unsafe { arr[(1) as usize].bump() });
+    let mut h: Holder = Holder::Holder(&mut c as *mut Counter);
+    (unsafe { h.c.bump() });
+    (unsafe { (*h.ref_).bump() });
+    (unsafe {
+        let _r: *mut Counter = &mut c as *mut Counter;
+        via_ref_0(_r)
+    });
+    let mut sum: i32 = (((((unsafe { (*p).get() }) + (unsafe { h.c.get() }))
+        + (unsafe { (*h.ref_).get() }))
+        + (unsafe { arr[(0) as usize].get() }))
+        + (unsafe { arr[(1) as usize].get() }));
+    printf(b"%d\n\0".as_ptr() as *const i8, sum);
+    return 0;
+}