Use ConvertFunctionPointerType for lambda operator()

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -131,16 +131,11 @@ bool Converter::VisitRecordType(clang::RecordType *type) {
   if (auto lambda = clang::dyn_cast<clang::CXXRecordDecl>(decl)) {
     if (lambda->isLambda()) {
       if (in_function_formals_) {
-        auto call_op = lambda->getLambdaCallOperator();
-        StrCat("impl Fn(");
-        for (auto p : call_op->parameters()) {
-          StrCat(std::format("{},", ToStringBase(p->getType())));
-        }
-        StrCat(")");
-        if (!call_op->getReturnType()->isVoidType()) {
-          StrCat("->");
-          StrCat(ToStringBase(call_op->getReturnType()));
-        }
+        StrCat(
+            ConvertFunctionPointerType(lambda->getLambdaCallOperator()
+                                           ->getType()
+                                           ->getAs<clang::FunctionProtoType>(),
+                                       FnProtoType::LambdaCallOperator));
       } else {
         StrCat("_");
       }
@@ -226,8 +221,10 @@ bool Converter::VisitLValueReferenceType(clang::LValueReferenceType *type) {
 }
 
 std::string
-Converter::ConvertFunctionPointerType(const clang::FunctionProtoType *proto) {
-  std::string result = "fn(";
+Converter::ConvertFunctionPointerType(const clang::FunctionProtoType *proto,
+                                      FnProtoType kind) {
+  std::string result =
+      (kind == FnProtoType::LambdaCallOperator ? "impl Fn(" : "fn(");
   for (auto p_ty : proto->param_types()) {
     result += ToString(p_ty) + ",";
   }

cpp2rust/converter/converter.h

@@ -61,8 +61,11 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitPointerType(clang::PointerType *type);
 
+  enum class FnProtoType { LambdaCallOperator, FnPtr };
+
   virtual std::string
-  ConvertFunctionPointerType(const clang::FunctionProtoType *proto);
+  ConvertFunctionPointerType(const clang::FunctionProtoType *proto,
+                             FnProtoType kind = FnProtoType::FnPtr);
 
   virtual bool VisitDecayedType(clang::DecayedType *type);
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -221,9 +221,9 @@ std::string ConverterRefCount::BuildFnAdapter(
 }
 
 std::string ConverterRefCount::ConvertFunctionPointerType(
-    const clang::FunctionProtoType *proto) {
+    const clang::FunctionProtoType *proto, FnProtoType kind) {
   PushConversionKind push(*this, ConversionKind::Unboxed);
-  return Converter::ConvertFunctionPointerType(proto);
+  return Converter::ConvertFunctionPointerType(proto, kind);
 }
 
 bool ConverterRefCount::VisitPointerType(clang::PointerType *type) {

cpp2rust/converter/models/converter_refcount.h

@@ -23,7 +23,8 @@ class ConverterRefCount final : public Converter {
   bool VisitPointerType(clang::PointerType *type) override;
 
   std::string
-  ConvertFunctionPointerType(const clang::FunctionProtoType *proto) override;
+  ConvertFunctionPointerType(const clang::FunctionProtoType *proto,
+                             FnProtoType kind = FnProtoType::FnPtr) override;
 
   bool VisitCXXRecordDecl(clang::CXXRecordDecl *decl) override;
 

tests/unit/lambda_capture_pass.cpp

@@ -0,0 +1,19 @@
+#include <assert.h>
+
+template <typename F> int apply(F fn, int x) { return fn(x); }
+
+int main() {
+  int base = 10;
+
+  auto add_base = [&base](int x) { return x + base; };
+  assert(apply(add_base, 5) == 15);
+
+  base = 100;
+  assert(apply(add_base, 5) == 105);
+
+  int factor = 3;
+  auto scale = [factor](int x) { return x * factor; };
+  assert(apply(scale, 4) == 12);
+
+  return 0;
+}

tests/unit/lambda_nested.cpp

@@ -0,0 +1,17 @@
+#include <assert.h>
+
+int main() {
+  int x = 10;
+
+  auto outer = [&x](int y) {
+    auto inner = [&x, y](int z) { return x + y + z; };
+    return inner(1);
+  };
+
+  assert(outer(20) == 31);
+
+  x = 100;
+  assert(outer(20) == 121);
+
+  return 0;
+}