Fix testsuite compilation

Author: nunoplopes

cpp2rust/converter/converter.cpp

@@ -2866,7 +2866,8 @@ bool Converter::IsReferenceType(const clang::Expr *expr) const {
            GetReturnTypeOfFunction(call)->isReferenceType();
   }
   if (const auto *decl_ref = clang::dyn_cast<clang::DeclRefExpr>(e)) {
-    return decl_ref->getDecl()->getType()->isReferenceType();
+    return GetDeclRefType(curr_function_, decl_ref, decl_ref->getDecl())
+        ->isReferenceType();
   }
   if (const auto *member = clang::dyn_cast<clang::MemberExpr>(e)) {
     return member->getMemberDecl()->getType()->isReferenceType();

tests/unit/lambda_capture_ref.cpp

@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>

tests/unit/out/refcount/lambda_capture_ref.rs

@@ -0,0 +1,104 @@
+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(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(8)]
+pub struct S {
+    #[offset(0)]
+    pub x: i32,
+    #[offset(4)]
+    pub y: i32,
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let base: Value<i32> = Rc::new(RefCell::new(10));
+    let add_base: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(lambda!(
+        {
+            let base: Ptr<i32> = base.as_pointer();
+        },
+        |x: i32| -> i32 {
+            let x: Value<i32> = Rc::new(RefCell::new(x));
+            return ((*x.borrow()) + (base.read()));
+        }
+    )));
+    assert!((({ (*add_base.borrow()).call(5,) }) == 15));
+    (*base.borrow_mut()) = 100;
+    assert!((({ (*add_base.borrow()).call(5,) }) == 105));
+    let s: Value<S> = Rc::new(RefCell::new(S { x: 1, y: 2 }));
+    let sum: Value<FnPtr<fn() -> i32>> = Rc::new(RefCell::new(lambda!(
+        {
+            let s: Ptr<S> = s.as_pointer();
+        },
+        || -> i32 {
+            return (s.with(|__s| __s.x) + s.with(|__s| __s.y));
+        }
+    )));
+    assert!((({ (*sum.borrow()).call() }) == 3));
+    (*s.borrow_mut()).x = 50;
+    assert!((({ (*sum.borrow()).call() }) == 52));
+    let counter: Value<i32> = Rc::new(RefCell::new(0));
+    let bump: Value<FnPtr<fn()>> = Rc::new(RefCell::new(lambda!(
+        {
+            let counter: Ptr<i32> = counter.as_pointer();
+        },
+        || {
+            counter.with_mut(|__v| __v.postfix_inc());
+        }
+    )));
+    ({ (*bump.borrow()).call() });
+    ({ (*bump.borrow()).call() });
+    assert!(((*counter.borrow()) == 2));
+    let arr: Value<Box<[u16]>> = Rc::new(RefCell::new(Box::new([3_u16, 1_u16, 2_u16, 0_u16])));
+    let swap: Value<FnPtr<fn(usize, usize)>> = Rc::new(RefCell::new(lambda!(
+        {
+            let arr: Ptr<u16> = arr.as_pointer();
+        },
+        |i: usize, j: usize| {
+            let i: Value<usize> = Rc::new(RefCell::new(i));
+            let j: Value<usize> = Rc::new(RefCell::new(j));
+            let t: Value<u16> = Rc::new(RefCell::new((elem!((arr), (*j.borrow())).read())));
+            elem!((arr), (*j.borrow())).write({ (elem!((arr), (*i.borrow())).read()) });
+            elem!((arr), (*i.borrow())).write((*t.borrow()));
+        }
+    )));
+    ({ (*swap.borrow()).call(0_usize, 3_usize) });
+    assert!((((*arr.borrow())[(0) as usize] as i32) == 0));
+    assert!((((*arr.borrow())[(3) as usize] as i32) == 3));
+    let total: Value<i32> = Rc::new(RefCell::new(0));
+    let add: Value<FnPtr<fn(i32)>> = Rc::new(RefCell::new(lambda!(
+        {
+            let t: Ptr<i32> = total.as_pointer();
+        },
+        |x: i32| {
+            let x: Value<i32> = Rc::new(RefCell::new(x));
+            {
+                let _ptr = t.clone();
+                _ptr.write(_ptr.read() + { (*x.borrow()) })
+            };
+        }
+    )));
+    ({ (*add.borrow()).call(2) });
+    ({ (*add.borrow()).call(3) });
+    assert!(((*total.borrow()) == 5));
+    let set_y: Value<FnPtr<fn(i32)>> = Rc::new(RefCell::new(lambda!(
+        {
+            let y: Ptr<i32> = field_ptr!(s.as_pointer(), y);
+        },
+        |v: i32| {
+            let v: Value<i32> = Rc::new(RefCell::new(v));
+            y.write({ (*v.borrow()) });
+        }
+    )));
+    ({ (*set_y.borrow()).call(9) });
+    assert!(({ (*s.borrow()).y } == 9));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/lambda_nested.rs

@@ -48,7 +48,7 @@ unsafe fn main_0() -> i32 {
         |y: i32| -> i32 {
             let mut inner: FnPtr<fn(i32) -> i32> = lambda_unsafe!(
                 {
-                    let x: *mut i32 = &mut (*x);
+                    let x: *mut i32 = x;
                     let y: i32 = y;
                 },
                 |z: i32| -> i32 {