Fix lambda calls, parameters, captures and namespace-scope lambdas (#501)

In VisitCallExpr convert the arguments of the operator call in Unboxed
context to avoid unnecessary Value boxes
Use ConvertVarDeclSkipInit to convert the params of the operator call so
that it can add mut where needed
PushConstInitializer(false) before converting the body of lambda to fix
translation of global lambdas
Call the move constructor when the lambda is moved
Fix generic lambdas with no specialisations in libcc2rs-macros
Fix lambda in lambda syntax in libcc2rs-macros

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4056,10 +4056,12 @@ void Converter::ConvertLambdaCapture(const clang::FieldDecl *field,
 void Converter::ConvertLambdaClosure(const clang::CXXRecordDecl *decl,
                                      clang::CXXMethodDecl *call_operator) {
   StrCat('|');
+  in_function_formals_ = true;
   for (auto p : call_operator->parameters()) {
-    StrCat(GetNamedDeclAsString(p), token::kColon, ToString(p->getType()),
-           token::kComma);
+    ConvertVarDeclSkipInit(p);
+    StrCat(token::kComma);
   }
+  in_function_formals_ = false;
   StrCat('|');
   ConvertFunctionReturnType(call_operator);
   PushBrace body(*this);
@@ -4070,6 +4072,7 @@ void Converter::ConvertLambdaClosure(const clang::CXXRecordDecl *decl,
   }
   EmitFunctionPreamble(call_operator);
   PushCurrFunction push_fn(*this, call_operator);
+  PushConstInitializer function_body(*this, false);
   ConvertFunctionBody(curr_function_);
 }
 

cpp2rust/converter/converter.h

@@ -856,18 +856,11 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   struct PushConstInitializer {
     Converter &c;
     bool prev;
-    bool enabled;
     PushConstInitializer(Converter &c, bool enabled)
-        : c(c), prev(c.in_const_initializer_), enabled(enabled) {
-      if (enabled) {
-        c.in_const_initializer_ = true;
-      }
-    }
-    ~PushConstInitializer() {
-      if (enabled) {
-        c.in_const_initializer_ = prev;
-      }
+        : c(c), prev(c.in_const_initializer_) {
+      c.in_const_initializer_ = enabled;
     }
+    ~PushConstInitializer() { c.in_const_initializer_ = prev; }
   };
   std::vector<clang::Expr *> curr_for_inc_;
   std::vector<clang::QualType> curr_init_type_;

cpp2rust/converter/converter_lib.cpp

@@ -1257,8 +1257,7 @@ const clang::LambdaCapture *AsLambdaCapture(const clang::FieldDecl *field) {
 
 bool IsLambdaCopyOrMoveConstructor(const clang::CXXConstructorDecl *ctor) {
   auto decl = ctor->getParent();
-  return ctor->isCopyOrMoveConstructor() && decl->isLambda() &&
-         !decl->captures().empty();
+  return ctor->isCopyOrMoveConstructor() && decl->isLambda();
 }
 
 bool LambdaNeedsDestruction(const clang::CXXRecordDecl *decl) {
@@ -1340,7 +1339,7 @@ bool HasStaticLocal(const clang::Stmt *stmt) {
 
 bool IsUserOperatorCall(const clang::CXXOperatorCallExpr *expr) {
   const auto *callee = expr->getDirectCallee();
-  if (!callee) {
+  if (!callee || AsLambdaOperatorCall(callee)) {
     return false;
   }
   if (callee->isDefaulted() && IsComparisonOperator(callee)) {

cpp2rust/converter/models/converter_refcount.cpp

@@ -1332,6 +1332,8 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
   if (auto *opcall = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr);
       opcall && !IsUserOperatorCall(opcall) &&
       !Mapper::Contains(ctx_, expr->getCallee())) {
+    PushConversionKind push(*this, ConversionKind::Unboxed,
+                            opcall->getOperator() == clang::OO_Call);
     return ConvertCXXOperatorCallExpr(opcall);
   }
 

libcc2rs-macros/src/lambda.rs

@@ -25,6 +25,13 @@ impl Parse for Lambda {
             input.parse::<Token![,]>()?;
         }
         let captures = input.parse()?;
+        if is_generic && input.is_empty() {
+            return Ok(Lambda {
+                is_generic,
+                captures,
+                closures: Vec::new(),
+            });
+        }
         input.parse::<Token![,]>()?;
         let mut closures = vec![input.parse()?];
         while input.parse::<Option<Token![,]>>()?.is_some() && !input.is_empty() {
@@ -60,8 +67,11 @@ fn rewrite_nested_lambda(
     tokens: proc_macro2::TokenStream,
     names: &HashSet<String>,
 ) -> Result<proc_macro2::TokenStream> {
-    let mut tokens = tokens.into_iter();
+    let mut tokens = tokens.into_iter().peekable();
     let mut out = Vec::new();
+    if is_ident(tokens.peek(), "Generic") {
+        out.extend(tokens.by_ref().take(2));
+    }
     if let Some(TokenTree::Group(captures)) = tokens.next() {
         let mut group = Group::new(
             captures.delimiter(),

tests/unit/lambda_as_field.cpp

@@ -1,6 +1,7 @@
 // ADDITIONAL_COMPILE_FLAGS: -std=c++23
 // no-compile
 #include <assert.h>
+#include <utility>
 
 template <typename F> struct Guard {
   F f;
@@ -16,6 +17,13 @@ template <typename F> struct Holder {
   }
 };
 
+template <typename F> struct Moving {
+  F f;
+  int moves = 0;
+  Moving(F f) : f(f) {}
+  Moving(Moving &&o) : f(std::move(o.f)), moves(o.moves + 1) {}
+};
+
 template <typename T> auto wrap(T fn) {
   return [fn](int x) { return fn(x) + 1; };
 }
@@ -54,5 +62,10 @@ int main() {
   auto ww = wrap(w);
   assert(ww(2) == 202);
 
+  Moving m{[](int x) { return x * 2; }};
+  Moving m2(std::move(m));
+  assert(m2.f(3) == 6);
+  assert(m2.moves == 1);
+
   return 0;
 }

tests/unit/lambda_as_template_argument.cpp

@@ -7,6 +7,11 @@ template <typename F> double apply_double(F fn, double x) { return fn(x); }
 
 template <typename F> int apply_twice(F fn, int x) { return fn(fn(x)); }
 
+template <typename Pred> bool none_match(Pred pred, int a, int b) {
+  auto neg_pred = [&](int x) { return !pred(x); };
+  return neg_pred(a) && neg_pred(b);
+}
+
 int main() {
   int factor = 3;
   auto scale = [factor](int x) { return x * factor; };
@@ -24,5 +29,9 @@ int main() {
   assert(apply_int(offset, 4) == 7);
   assert(apply_double(offset, 1.5) == 4.5);
 
+  auto is_even = [](int x) { return x % 2 == 0; };
+  assert(none_match(is_even, 1, 3));
+  assert(!none_match(is_even, 1, 4));
+
   return 0;
 }

tests/unit/lambda_basic.cpp

@@ -22,5 +22,24 @@ int main() {
   auto implicit = [=](int x) { return x + k; };
   assert(implicit(1) == 4);
 
+  auto bump = [](int x) {
+    x += 1;
+    return x;
+  };
+  assert(bump(1) == 2);
+
+  auto through_ptr = [](int x) {
+    int *p = &x;
+    *p = *p * 2;
+    return x;
+  };
+  assert(through_ptr(4) == 8);
+
+  int seed = 5;
+  int boxed = through_ptr(seed);
+  int *boxed_ptr = &boxed;
+  assert(*boxed_ptr == 10);
+  assert(seed == 5);
+
   return 0;
 }

tests/unit/lambda_generic.cpp

@@ -27,5 +27,14 @@ int main() {
   assert(mixed(2, 3) == 16);
   assert(mixed(2, 0.5) == 11.0);
 
+  auto unused = [](auto x) { return x; };
+  (void)unused;
+
+  auto outer = [base](int y) {
+    auto inner = [](auto z) { return z + 1; };
+    return inner(y) + base;
+  };
+  assert(outer(5) == 16);
+
   return 0;
 }

tests/unit/lambda_namespace_scope.cpp

@@ -10,6 +10,10 @@ auto bump = []() {
 
 template <typename F> int apply(F f, int x) { return f(x); }
 
+int by_ref(const int &v) { return v * 2; }
+
+auto twice_next = [](int x) { return by_ref(x + 1); };
+
 int main() {
   assert(inc(41) == 42);
 
@@ -25,5 +29,7 @@ int main() {
   int (*fp)(int) = inc;
   assert(fp(-1) == 0);
 
+  assert(twice_next(4) == 10);
+
   return 0;
 }