Fix address of static method (#409)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1896,9 +1896,18 @@ void Converter::EmitFnPtrCall(clang::Expr *callee) {
   StrCat(".unwrap()");
 }
 
+std::string Converter::GetFunctionRefName(const clang::FunctionDecl *fn_decl) {
+  if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(fn_decl);
+      method && method->isStatic()) {
+    return std::format("{}::{}", GetRecordName(method->getParent()),
+                       GetMethodName(method));
+  }
+  return Mapper::MapFunctionName(fn_decl);
+}
+
 void Converter::ConvertFunctionToFunctionPointer(
     const clang::FunctionDecl *fn_decl) {
-  StrCat(std::format("Some({})", Mapper::MapFunctionName(fn_decl)));
+  StrCat(std::format("Some({})", GetFunctionRefName(fn_decl)));
   computed_expr_type_ = ComputedExprType::FreshPointer;
 }
 
@@ -3015,8 +3024,7 @@ std::string Converter::ConvertDeclRefExpr(clang::DeclRefExpr *expr) {
   if (auto *function = decl->getAsFunction()) {
     if (auto method = clang::dyn_cast<clang::CXXMethodDecl>(function)) {
       if (method->isStatic()) {
-        return std::format("{}::{}", GetRecordName(method->getParent()),
-                           GetNamedDeclAsString(method));
+        return GetFunctionRefName(method);
       }
     }
     return GetNamedDeclAsString(function->getCanonicalDecl());

cpp2rust/converter/converter.h

@@ -314,6 +314,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual void
   ConvertFunctionToFunctionPointer(const clang::FunctionDecl *fn_decl);
 
+  std::string GetFunctionRefName(const clang::FunctionDecl *fn_decl);
+
   std::string ConvertFnPtrCallee(clang::Expr *arg);
   virtual std::string ConvertFnPtrPlaceholder(clang::Expr *arg);
 

cpp2rust/converter/models/converter_refcount.cpp

@@ -1352,7 +1352,7 @@ void ConverterRefCount::ConvertFunctionToFunctionPointer(
   StrCat(std::format("FnPtr::<{}>::new({})",
                      ConvertFunctionPointerType(
                          fn_decl->getType()->getAs<clang::FunctionProtoType>()),
-                     Mapper::MapFunctionName(fn_decl)));
+                     GetFunctionRefName(fn_decl)));
   computed_expr_type_ = ComputedExprType::FreshPointer;
 }
 

tests/unit/fn_ptr_struct.cpp

@@ -10,7 +10,22 @@ struct Handler {
 int double_it(int x) { return x * 2; }
 int negate(int x) { return -x; }
 
+struct S {
+  static int pick(int x) { return x + 1; }
+  static int pick(long x) { return (int)x + 2; }
+  static int solo(int x) { return x + 3; }
+};
+
 int main() {
+  handler_t p1 = &S::pick;
+  handler_t p2 = S::solo;
+  assert(p1(5) == 6);
+  assert(p2(5) == 8);
+  assert(S::pick(5L) == 7);
+
+  Handler h3 = {3, &S::pick};
+  assert(h3.cb(1) == 2);
+
   Handler h1 = {1, double_it};
   Handler h2 = {2, negate};
 

tests/unit/out/refcount/fn_ptr_struct.rs

@@ -54,11 +54,39 @@ pub fn negate_1(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     return -(*x.borrow());
 }
+#[derive(Clone, ByteRepr, Default)]
+pub struct S {}
+impl S {
+    pub fn pick_i32(x: i32) -> i32 {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        return ((*x.borrow()) + 1);
+    }
+    pub fn pick_i64(x: i64) -> i32 {
+        let x: Value<i64> = Rc::new(RefCell::new(x));
+        return (((*x.borrow()) as i32) + 2);
+    }
+    pub fn solo(x: i32) -> i32 {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        return ((*x.borrow()) + 3);
+    }
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
+    let p1: Value<FnPtr<fn(i32) -> i32>> =
+        Rc::new(RefCell::new((FnPtr::<fn(i32) -> i32>::new(S::pick_i32))));
+    let p2: Value<FnPtr<fn(i32) -> i32>> =
+        Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(S::solo)));
+    assert!((({ (*(*p1.borrow()))(5,) }) == 6));
+    assert!((({ (*(*p2.borrow()))(5,) }) == 8));
+    assert!((({ S::pick_i64(5_i64,) }) == 7));
+    let h3: Value<Handler> = Rc::new(RefCell::new(Handler {
+        tag: Rc::new(RefCell::new(3)),
+        cb: Rc::new(RefCell::new((FnPtr::<fn(i32) -> i32>::new(S::pick_i32)))),
+    }));
+    assert!((({ (*(*(*h3.borrow()).cb.borrow()))(1,) }) == 2));
     let h1: Value<Handler> = Rc::new(RefCell::new(Handler {
         tag: Rc::new(RefCell::new(1)),
         cb: Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(double_it_0))),

tests/unit/out/unsafe/fn_ptr_struct.rs

@@ -26,13 +26,37 @@ pub unsafe fn double_it_0(mut x: i32) -> i32 {
 pub unsafe fn negate_1(mut x: i32) -> i32 {
     return -x;
 }
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct S {}
+impl S {
+    pub unsafe fn pick_i32(mut x: i32) -> i32 {
+        return ((x) + (1));
+    }
+    pub unsafe fn pick_i64(mut x: i64) -> i32 {
+        return ((x as i32) + (2));
+    }
+    pub unsafe fn solo(mut x: i32) -> i32 {
+        return ((x) + (3));
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
+    let mut p1: Option<unsafe fn(i32) -> i32> = (Some(S::pick_i32));
+    let mut p2: Option<unsafe fn(i32) -> i32> = Some(S::solo);
+    assert!(((unsafe { (p1).unwrap()(5,) }) == (6)));
+    assert!(((unsafe { (p2).unwrap()(5,) }) == (8)));
+    assert!(((unsafe { S::pick_i64(5_i64,) }) == (7)));
+    let mut h3: Handler = Handler {
+        tag: 3,
+        cb: (Some(S::pick_i32)),
+    };
+    assert!(((unsafe { (h3.cb).unwrap()(1,) }) == (2)));
     let mut h1: Handler = Handler {
         tag: 1,
         cb: Some(double_it_0),