Translate static invoke for lambdas

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4,6 +4,7 @@
 #include "converter/converter.h"
 
 #include <clang/AST/APValue.h>
+#include <clang/AST/IgnoreExpr.h>
 #include <clang/AST/ParentMapContext.h>
 #include <clang/Basic/LangOptions.h>
 #include <clang/Basic/SourceManager.h>
@@ -2004,6 +2005,16 @@ std::string Converter::GetFunctionRefName(const clang::FunctionDecl *fn_decl) {
 
 void Converter::ConvertFunctionToFunctionPointer(
     const clang::FunctionDecl *fn_decl) {
+  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(fn_decl);
+      method && method->isLambdaStaticInvoker()) {
+    assert(!method->getParent()->isGenericLambda());
+    StrCat("Some");
+    PushParen paren(*this);
+    ConvertLambdaClosure(method->getParent(),
+                         method->getParent()->getLambdaCallOperator());
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return;
+  }
   StrCat(std::format("Some({})", GetFunctionRefName(fn_decl)));
   computed_expr_type_ = ComputedExprType::FreshPointer;
 }
@@ -2055,7 +2066,11 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
   unsigned num_named_params =
       function ? function->getNumParams() : proto->getNumParams();
   info.is_variadic = function ? function->isVariadic() : proto->isVariadic();
-  info.is_fn_ptr_call = !function || AsLambdaClass(callee->getType());
+  info.is_fn_ptr_call =
+      !function || AsLambdaClass(callee->getType()) ||
+      clang::isa<clang::SubstNonTypeTemplateParmExpr>(
+          clang::IgnoreExprNodes(callee, clang::IgnoreParensSingleStep,
+                                 clang::IgnoreImplicitCastsSingleStep));
   info.is_libc_passthrough = RuleRegistry::IsLibcPassthrough(ctx_, expr);
 
   for (unsigned i = 0; i < num_named_params && i < num_args; ++i) {

cpp2rust/converter/models/converter_refcount.cpp

@@ -1567,6 +1567,12 @@ void ConverterRefCount::ConvertLambdaToFunctionPointer(
 
 void ConverterRefCount::ConvertFunctionToFunctionPointer(
     const clang::FunctionDecl *fn_decl) {
+  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(fn_decl);
+      method && method->isLambdaStaticInvoker()) {
+    ConvertCapturelessLambda(method->getParent());
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return;
+  }
   StrCat(std::format("FnPtr::<{}>::new({})",
                      ConvertFunctionPointerType(
                          fn_decl->getType()->getAs<clang::FunctionProtoType>()),

tests/unit/out/refcount/lambda_to_fn_ptr.rs

@@ -10,10 +10,24 @@ 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) });
+    return ({
+        (FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+            {
+                return (x - 1);
+            }
+        }))
+        .call(x)
+    });
 }
 pub fn call_nttp_2(mut x: i32) -> i32 {
-    return ({ (FnPtr::<fn(i32) -> i32>::new(int_operator___int__const::__invoke))(x) });
+    return ({
+        (FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
+            {
+                return (x * 10);
+            }
+        }))
+        .call(x)
+    });
 }
 pub fn call_nttp_3(mut x: i32) -> i32 {
     return ({

tests/unit/out/unsafe/lambda_to_fn_ptr.rs

@@ -10,10 +10,24 @@ 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) });
+    return (unsafe {
+        (Some(|mut x: i32| -> i32 {
+            unsafe {
+                return ((x) - (1));
+            }
+        }))
+        .unwrap()(x)
+    });
 }
 pub unsafe fn call_nttp_2(mut x: i32) -> i32 {
-    return (unsafe { (Some(int_operator___int__const::__invoke))(x) });
+    return (unsafe {
+        (Some(|mut x: i32| -> i32 {
+            unsafe {
+                return ((x) * (10));
+            }
+        }))
+        .unwrap()(x)
+    });
 }
 pub unsafe fn call_nttp_3(mut x: i32) -> i32 {
     return (unsafe {