Translate lambda TPOs

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -3232,6 +3232,13 @@ std::string Converter::ConvertDeclRef(clang::Expr *expr,
 }
 
 bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
+  if (auto param =
+          clang::dyn_cast<clang::TemplateParamObjectDecl>(expr->getDecl());
+      param && AsLambdaClass(param->getType())) {
+    StrCat(GetDefaultAsString(param->getType()));
+    computed_expr_type_ = ComputedExprType::FreshValue;
+    return false;
+  }
   if (auto init = AsLambdaUncapturedConstant(curr_function_, expr)) {
     Convert(init);
     return false;

tests/unit/out/refcount/lambda_to_fn_ptr.rs

@@ -0,0 +1,81 @@
+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};
+pub fn apply_0(mut x: i32, mut fn_: FnPtr<fn(i32) -> i32>) -> i32 {
+    return ({ fn_.call(x) });
+}
+pub fn call_nttp_1(mut x: i32) -> i32 {
+    return ({ (FnPtr::<fn(i32) -> i32>::new(int_operator___int__const::__invoke))(x) });
+}
+pub fn call_nttp_1(mut x: i32) -> i32 {
+    return ({ (FnPtr::<fn(i32) -> i32>::new(int_operator___int__const::__invoke))(x) });
+}
+pub fn call_nttp_2(mut x: i32) -> i32 {
+    return ({
+        FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+            {
+                return (x + 100);
+            }
+        })
+        .call(x)
+    });
+}
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let mut fresh: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+        {
+            return -x;
+        }
+    });
+    assert!((({ fresh.call(5,) }) == -5_i32));
+    let twice: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(
+        |mut x: i32| -> i32 {
+            {
+                return (x * 2);
+            }
+        },
+    )));
+    let mut named: FnPtr<fn(i32) -> i32> = (*twice.borrow()).clone();
+    assert!((({ named.call(5,) }) == 10));
+    assert!((({ apply_0(5, (*twice.borrow()).clone(),) }) == 10));
+    named = (fresh).clone();
+    assert!((({ named.call(3,) }) == -3_i32));
+    let mut p: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+        {
+            return (x * 3);
+        }
+    });
+    assert!((({ p.call(2,) }) == 6));
+    assert!((({ call_nttp_1(5,) }) == 4));
+    assert!((({ call_nttp_1(5,) }) == 50));
+    assert!((({ call_nttp_2(5,) }) == 105));
+    let sum: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(
+        |n: i32| -> i32 {
+            {
+                let __args: Value<Box<[VaArg]>> = Rc::new(RefCell::new(__args.into()));
+                let n: Value<i32> = Rc::new(RefCell::new(n));
+                let ap: Value<Ptr<VaArg>> = Rc::new(RefCell::new(Ptr::<VaArg>::default()));
+                (*ap.borrow_mut()) = __args.as_pointer();
+                let s: Value<i32> = Rc::new(RefCell::new(0));
+                let mut i: i32 = 0;
+                'loop_: while (i < (*n.borrow())) {
+                    (*s.borrow_mut()) += (*ap.borrow_mut()).arg::<i32>();
+                    i.postfix_inc();
+                }
+                return (*s.borrow());
+            }
+        },
+    )));
+    assert!((({ (*sum.borrow()).call(2, &[(5).into(), (5).into(),]) }) == 10));
+    assert!((({ (*sum.borrow()).call(3, &[(1).into(), (2).into(), (3).into(),]) }) == 6));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/lambda_to_fn_ptr.rs

@@ -0,0 +1,92 @@
+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;
+pub unsafe fn apply_0(mut x: i32, mut fn_: Option<unsafe fn(i32) -> i32>) -> i32 {
+    return (unsafe { (fn_).unwrap()(x) });
+}
+pub unsafe fn call_nttp_1(mut x: i32) -> i32 {
+    return (unsafe { (Some(int_operator___int__const::__invoke))(x) });
+}
+pub unsafe fn call_nttp_1(mut x: i32) -> i32 {
+    return (unsafe { (Some(int_operator___int__const::__invoke))(x) });
+}
+pub unsafe fn call_nttp_2(mut x: i32) -> i32 {
+    return (unsafe {
+        FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+            unsafe {
+                return ((x) + (100));
+            }
+        })
+        .call(x)
+    });
+}
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut fresh: Option<unsafe fn(i32) -> i32> = Some(|mut x: i32| -> i32 {
+        unsafe {
+            return -x;
+        }
+    });
+    assert!(((unsafe { (fresh).unwrap()(5,) }) == (-5_i32)));
+    let mut twice: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+        unsafe {
+            return ((x) * (2));
+        }
+    });
+    let mut named: Option<unsafe fn(i32) -> i32> = Some(|mut x: i32| -> i32 {
+        unsafe {
+            return ((x) * (2));
+        }
+    });
+    assert!(((unsafe { (named).unwrap()(5,) }) == (10)));
+    assert!(
+        ((unsafe {
+            apply_0(
+                5,
+                Some(|mut x: i32| -> i32 {
+                    unsafe {
+                        return ((x) * (2));
+                    }
+                }),
+            )
+        }) == (10))
+    );
+    named = fresh;
+    assert!(((unsafe { (named).unwrap()(3,) }) == (-3_i32)));
+    let mut p: Option<unsafe fn(i32) -> i32> = Some(|mut x: i32| -> i32 {
+        unsafe {
+            return ((x) * (3));
+        }
+    });
+    assert!(((unsafe { (p).unwrap()(2,) }) == (6)));
+    assert!(((unsafe { call_nttp_1(5,) }) == (4)));
+    assert!(((unsafe { call_nttp_1(5,) }) == (50)));
+    assert!(((unsafe { call_nttp_2(5,) }) == (105)));
+    let mut sum: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|mut n: i32| -> i32 {
+        unsafe {
+            let mut ap: *const VaArg = ::std::ptr::null();
+            ap = __args.as_ptr();
+            let mut s: i32 = 0;
+            let mut i: i32 = 0;
+            'loop_: while ((i) < (n)) {
+                s += ap.arg::<i32>();
+                i.postfix_inc();
+            }
+            return s;
+        }
+    });
+    assert!(((unsafe { sum.call(2, &[(5).into(), (5).into(),]) }) == (10)));
+    assert!(((unsafe { sum.call(3, &[(1).into(), (2).into(), (3).into(),]) }) == (6)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}