Insert missing pointer-type cast for call arguments when Clang omits an implicit cast node

Co-authored-by: nunoplopes <2998477+nunoplopes@users.noreply.github.com>

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -1875,6 +1875,29 @@ void Converter::ConvertParamTy(clang::QualType param_type, clang::Expr *expr) {
   } else {
     ConvertVarInit(param_type, expr);
   }
+  ConvertParamTyPointerCastIfNeeded(param_type, expr);
+}
+
+void Converter::ConvertParamTyPointerCastIfNeeded(clang::QualType param_type,
+                                                  clang::Expr *expr) {
+  if (!param_type->isPointerType() || !expr->getType()->isPointerType() ||
+      IsVaListType(param_type) || IsVaListType(expr->getType())) {
+    return;
+  }
+  switch (GetConstCastType(param_type->getPointeeType(),
+                           expr->getType()->getPointeeType())) {
+  case ConstCastType::MutableToConst:
+    StrCat(".cast_const()");
+    return;
+  case ConstCastType::ConstToMutable:
+    StrCat(".cast_mut()");
+    return;
+  default:
+    break;
+  }
+  if (!IsCastRedundantInRust(expr, param_type)) {
+    ConvertCast(param_type);
+  }
 }
 
 void Converter::EmitHoistedArgs(CallInfo &info) {

cpp2rust/converter/converter.h

@@ -282,6 +282,15 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   void ConvertParamTy(clang::QualType param_type, clang::Expr *expr);
 
+  // Emits a pointer-type adjustment (const/mut fixup or reinterpret cast)
+  // after `expr` has been converted, for cases where the argument's Rust
+  // pointee type differs from the parameter's Rust pointee type even though
+  // Clang did not insert an implicit cast node for the call argument (e.g.
+  // when two C types are canonically identical, such as `size_t` and
+  // `unsigned long`, but map to different Rust types).
+  virtual void ConvertParamTyPointerCastIfNeeded(clang::QualType param_type,
+                                                 clang::Expr *expr);
+
   void EmitHoistedArgs(CallInfo &info);
 
   void EmitArgList(const CallInfo &info);

cpp2rust/converter/models/converter_refcount.cpp

@@ -2596,6 +2596,18 @@ std::string ConverterRefCount::ConvertPointeeType(clang::QualType ptr_type) {
   return std::string(Trim(str));
 }
 
+void ConverterRefCount::ConvertParamTyPointerCastIfNeeded(
+    clang::QualType param_type, clang::Expr *expr) {
+  if (!param_type->isPointerType() || !expr->getType()->isPointerType() ||
+      IsVaListType(param_type) || IsVaListType(expr->getType())) {
+    return;
+  }
+  auto dest_type = ConvertPointeeType(param_type);
+  if (dest_type != ConvertPointeeType(expr->getType())) {
+    StrCat(std::format(".reinterpret_cast::<{}>()", dest_type));
+  }
+}
+
 bool ConverterRefCount::ShouldConvertMethod(const clang::CXXMethodDecl *decl) {
   if (clang::isa<clang::CXXDestructorDecl>(decl)) {
     return IsMethodOnPtr(decl);

cpp2rust/converter/models/converter_refcount.h

@@ -263,6 +263,9 @@ class ConverterRefCount final : public Converter {
   std::string ConvertPtrType(clang::QualType type);
   std::string ConvertPointeeType(clang::QualType ptr_type) override;
 
+  void ConvertParamTyPointerCastIfNeeded(clang::QualType param_type,
+                                         clang::Expr *expr) override;
+
   std::string ConvertSubscriptIndex(clang::Expr *idx);
 
   std::string GetSafeTypeAsString(clang::QualType qual_type) const;

tests/unit/out/refcount/implicit_ptr_cast.rs

@@ -15,7 +15,7 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let x: Value<usize> = Rc::new(RefCell::new(0_usize));
-    ({ write_ulong_0((x.as_pointer().reinterpret_cast::<u64>())) });
+    ({ write_ulong_0((x.as_pointer()).reinterpret_cast::<u64>()) });
     assert!(((((*x.borrow()) == 42_usize) as i32) != 0));
     return 0;
 }

tests/unit/out/unsafe/implicit_ptr_cast.rs

@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn write_ulong_0(p: *mut u64) {
+pub unsafe fn write_ulong_0(mut p: *mut u64) {
     (*p) = 42_u64;
 }
 pub fn main() {
@@ -16,7 +16,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut x: usize = 0_usize;
-    (unsafe { write_ulong_0((&mut x as *mut usize as *mut u64)) });
+    (unsafe { write_ulong_0((&mut x as *mut usize) as *mut u64) });
     assert!(((((x) == (42_usize)) as i32) != 0));
     return 0;
 }