Fix mismatched u64/usize in function pointer signature

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -236,6 +236,17 @@ Converter::MaterializeTemp(const std::string &binding_name,
   auto pointee = param_type.getNonReferenceType();
   auto value = ConvertRValue(expr, pointee);
   auto type_str = ToStringBase(pointee);
+  auto src_type = expr->IgnoreImplicit()->getType().getNonReferenceType();
+  if (src_type->isFunctionType()) {
+    src_type = ctx_.getPointerType(src_type);
+  }
+  if (pointee->isFunctionPointerType() && src_type->isFunctionPointerType()) {
+    auto src_str = ToStringBase(src_type);
+    if (src_str != type_str) {
+      value = std::format("std::mem::transmute::<{}, {}>({})", src_str,
+                          type_str, value);
+    }
+  }
   const auto *decl = in_const_initializer_ ? keyword::kStatic : keyword::kLet;
 
   auto binding =

cpp2rust/converter/models/converter_refcount.cpp

@@ -411,7 +411,9 @@ ConverterRefCount::MaterializeTemp(const std::string &binding_name,
                                    clang::QualType param_type,
                                    clang::Expr *expr) {
   auto pointee = param_type.getNonReferenceType();
-  auto value = ConvertRValue(expr, pointee);
+  auto value = pointee->isFunctionPointerType()
+                   ? ConvertFnPtrValue(pointee, expr)
+                   : ConvertRValue(expr, pointee);
   auto type_str = ToStringBase(pointee);
   const auto *decl = in_const_initializer_ ? keyword::kStatic : keyword::kLet;
 
@@ -2357,11 +2359,15 @@ std::string ConverterRefCount::ConvertFnPtrValue(clang::QualType qual_type,
   // automatically, so just insert it whenever the two differ.
   auto target_proto =
       qual_type->getPointeeType()->getAs<clang::FunctionProtoType>();
-  if (!target_proto || !expr->getType()->isFunctionPointerType()) {
+  auto src_type = expr->IgnoreImplicit()->getType().getNonReferenceType();
+  if (src_type->isFunctionType()) {
+    src_type = ctx_.getPointerType(src_type);
+  }
+  if (!target_proto || !src_type->isFunctionPointerType()) {
     return base;
   }
   auto src_proto =
-      expr->getType()->getPointeeType()->getAs<clang::FunctionProtoType>();
+      src_type->getPointeeType()->getAs<clang::FunctionProtoType>();
   if (!src_proto) {
     return base;
   }

tests/unit/fn_ptr.cpp

@@ -1,11 +1,25 @@
 #include <assert.h>
+#include <cstddef>
 
 typedef int (*foo_t)(void *);
 
 int my_foo(void *p) { return *static_cast<int *>(p); }
 
 int foo(foo_t fn, int *pi) { return fn(pi); }
 
+template <class T> static size_t ret_size(T v) { return v + 1; }
+
+template <class T> static size_t call_fn(size_t (*f)(T), T v) {
+  return f(v) * 2;
+}
+
+template <class T> static std::size_t identity_hash(T v) { return v; }
+
+template <class H> struct HashHolder {
+  H h;
+  HashHolder(const H &h) : h(h) {}
+};
+
 int main() {
   foo_t fn = nullptr;
   assert(fn == nullptr);
@@ -17,5 +31,10 @@ int main() {
 
   int a = 10;
   assert(foo(fn, &a) == a);
+
+  assert(call_fn(ret_size<int>, 3) == 8);
+
+  HashHolder<std::size_t (*)(bool)> hh(identity_hash<bool>);
+  assert(hh.h(true) == 1);
   return 0;
 }

tests/unit/out/refcount/fn_ptr.rs

@@ -15,6 +15,42 @@ pub fn foo_1(fn_: FnPtr<fn(AnyPtr) -> i32>, pi: Ptr<i32>) -> i32 {
     let pi: Value<Ptr<i32>> = Rc::new(RefCell::new(pi));
     return ({ (*fn_.borrow()).call((*pi.borrow()).to_any()) });
 }
+pub fn ret_size_2(v: i32) -> usize {
+    let v: Value<i32> = Rc::new(RefCell::new(v));
+    return (((*v.borrow()) + 1) as usize);
+}
+pub fn call_fn_3(f: FnPtr<fn(i32) -> usize>, v: i32) -> usize {
+    let f: Value<FnPtr<fn(i32) -> usize>> = Rc::new(RefCell::new(f));
+    let v: Value<i32> = Rc::new(RefCell::new(v));
+    return ({ (*f.borrow()).call((*v.borrow())) }).wrapping_mul(2_usize);
+}
+pub fn identity_hash_4(v: bool) -> usize {
+    let v: Value<bool> = Rc::new(RefCell::new(v));
+    return ((*v.borrow()) as usize);
+}
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg)]
+#[byte_size(8)]
+pub struct HashHolder_unsigned_long__ptr__bool__ {
+    #[offset(0)]
+    #[byte_size(8)]
+    pub h: FnPtr<fn(bool) -> u64>,
+}
+impl HashHolder_unsigned_long__ptr__bool__ {
+    pub fn new(h: Ptr<FnPtr<fn(bool) -> u64>>) -> Self {
+        let __this: Value<HashHolder_unsigned_long__ptr__bool__> = Rc::new(RefCell::new(Self {
+            h: (h.read()).clone(),
+        }));
+        let this: Ptr<HashHolder_unsigned_long__ptr__bool__> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Default for HashHolder_unsigned_long__ptr__bool__ {
+    fn default() -> Self {
+        HashHolder_unsigned_long__ptr__bool__ {
+            h: FnPtr::<fn(bool) -> u64>::null(),
+        }
+    }
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -29,6 +65,14 @@ fn main_0() -> i32 {
     assert!(({ (*fn_.borrow()).clone() } == { FnPtr::<fn(AnyPtr) -> i32>::new(my_foo_0) }));
     let a: Value<i32> = Rc::new(RefCell::new(10));
     assert!(({ ({ foo_1((*fn_.borrow()).clone(), (a.as_pointer()),) }) } == { (*a.borrow()) }));
+    assert!((({ call_fn_3(FnPtr::<fn(i32) -> usize>::new(ret_size_2), 3,) }) == 8_usize));
+    let hh: Value<HashHolder_unsigned_long__ptr__bool__> = Rc::new(RefCell::new({
+        let __tmp_0: Value<FnPtr<fn(bool) -> u64>> = Rc::new(RefCell::new(
+            FnPtr::<fn(bool) -> usize>::new(identity_hash_4).cast::<fn(bool) -> u64>(),
+        ));
+        HashHolder_unsigned_long__ptr__bool__::new({ __tmp_0.as_pointer() })
+    }));
+    assert!((({ { (*hh.borrow()).h.clone() }.call(true,) }) == 1_u64));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/fn_ptr.rs

@@ -15,6 +15,31 @@ pub unsafe fn foo_1(
 ) -> i32 {
     return (unsafe { (fn_).unwrap()((pi as *mut ::libc::c_void)) });
 }
+pub unsafe fn ret_size_2(mut v: i32) -> usize {
+    return (((v) + (1)) as usize);
+}
+pub unsafe fn call_fn_3(mut f: Option<unsafe fn(i32) -> usize>, mut v: i32) -> usize {
+    return (unsafe { (f).unwrap()(v) }).wrapping_mul(2_usize);
+}
+pub unsafe fn identity_hash_4(mut v: bool) -> usize {
+    return (v as usize);
+}
+#[repr(C)]
+#[derive(Copy, Clone, VaArg)]
+pub struct HashHolder_unsigned_long__ptr__bool__ {
+    pub h: Option<unsafe fn(bool) -> u64>,
+}
+impl HashHolder_unsigned_long__ptr__bool__ {
+    pub unsafe fn new(h: *const Option<unsafe fn(bool) -> u64>) -> Self {
+        let mut this = Self { h: (*h) };
+        this
+    }
+}
+impl Default for HashHolder_unsigned_long__ptr__bool__ {
+    fn default() -> Self {
+        HashHolder_unsigned_long__ptr__bool__ { h: None }
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -30,6 +55,15 @@ unsafe fn main_0() -> i32 {
     assert!(((fn_) == (Some(my_foo_0))));
     let mut a: i32 = 10;
     assert!(((unsafe { foo_1(fn_, (&mut a as *mut i32),) }) == (a)));
+    assert!(((unsafe { call_fn_3(Some(ret_size_2), 3,) }) == (8_usize)));
+    let mut hh: HashHolder_unsigned_long__ptr__bool__ = {
+        let mut __tmp_0: Option<unsafe fn(bool) -> u64> = std::mem::transmute::<
+            Option<unsafe fn(bool) -> usize>,
+            Option<unsafe fn(bool) -> u64>,
+        >(Some(identity_hash_4));
+        HashHolder_unsigned_long__ptr__bool__::new({ &mut __tmp_0 })
+    };
+    assert!(((unsafe { (hh.h).unwrap()(true,) }) == (1_u64)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}