Fix #319: Fix implicit pointer cast between types with different Rust representations (#336)

When size_t and unsigned long (or similar typedef-aliased types) are used
interchangeably as pointer types, Clang emits a CK_NoOp ImplicitCastExpr
in the AST.
The translator was silently dropping this, producing a type mismatch in
the generated Rust code (`Ptr<usize>` passed where `Ptr<u64>` is expected).

---------

Co-authored-by: Nuno Lopes <nuno.lopes@tecnico.ulisboa.pt>

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -119,13 +119,13 @@ std::string Converter::ConvertPointeeType(clang::QualType ptr_type) {
   assert(!ptr_type.isNull() && ptr_type->isPointerType());
   auto pointee = ptr_type->getPointeeType();
   if (!pointee->isRecordType()) {
-    return ToString(pointee);
+    return std::string(Trim(ToString(pointee)));
   }
 
   auto str = ToString(ptr_type);
   Unwrap(str, "*mut ", "");
   Unwrap(str, "*const ", "");
-  return str;
+  return std::string(Trim(str));
 }
 
 bool Converter::VisitBuiltinType(clang::BuiltinType *type) {
@@ -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) {
@@ -2257,6 +2280,7 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   }
   case clang::CastKind::CK_NoOp: {
     const char *suffix = nullptr;
+    bool type_changed = false;
     if (expr->getType()->isPointerType() &&
         sub_expr->getType()->isPointerType() &&
         !clang::isa<clang::CXXThisExpr>(expr->IgnoreImplicit())) {
@@ -2269,15 +2293,22 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
         suffix = ".cast_mut()";
         break;
       default:
+        type_changed = !IsCastRedundantInRust(sub_expr, type);
         break;
       }
     }
-    {
-      PushParen paren(*this, suffix);
+    if (type_changed) {
+      PushParen paren(*this);
       Convert(sub_expr);
-    }
-    if (suffix) {
-      StrCat(suffix);
+      ConvertCast(type);
+    } else {
+      {
+        PushParen paren(*this, suffix);
+        Convert(sub_expr);
+      }
+      if (suffix) {
+        StrCat(suffix);
+      }
     }
     break;
   }

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

@@ -1241,6 +1241,16 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
 
   if (expr->getCastKind() == clang::CastKind::CK_NoOp) {
     Convert(sub_expr);
+
+    if (expr->getType()->isPointerType() &&
+        sub_expr->getType()->isPointerType()) {
+      auto dest_type = ConvertPointeeType(expr->getType());
+      if (dest_type != ConvertPointeeType(sub_expr->getType())) {
+        StrCat(std::format(".reinterpret_cast::<{}>()", dest_type));
+        computed_expr_type_ = ComputedExprType::FreshPointer;
+        return false;
+      }
+    }
     return false;
   }
 
@@ -2574,7 +2584,7 @@ std::string ConverterRefCount::ConvertPointeeType(clang::QualType ptr_type) {
   PushConversionKind push(*this, ConversionKind::Unboxed);
   auto pointee = ptr_type->getPointeeType();
   if (!pointee->isRecordType()) {
-    return ToString(pointee);
+    return std::string(Trim(ToString(pointee)));
   }
 
   // Pointee of a pointer to incomplete type is an incomplete type that does
@@ -2583,7 +2593,19 @@ std::string ConverterRefCount::ConvertPointeeType(clang::QualType ptr_type) {
   auto str = ToString(ptr_type);
   Unwrap(str, "PtrDyn<", ">");
   Unwrap(str, "Ptr<", ">");
-  return str;
+  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) {

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/implicit_ptr_cast.c

@@ -0,0 +1,11 @@
+#include <assert.h>
+#include <stddef.h>
+
+static void write_ulong(unsigned long *p) { *p = 42; }
+
+int main(void) {
+  size_t x = 0;
+  write_ulong(&x);
+  assert(x == 42);
+  return 0;
+}

tests/unit/out/refcount/implicit_ptr_cast.rs

@@ -0,0 +1,21 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn write_ulong_0(p: Ptr<u64>) {
+    let p: Value<Ptr<u64>> = Rc::new(RefCell::new(p));
+    (*p.borrow()).write(42_u64);
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let x: Value<usize> = Rc::new(RefCell::new(0_usize));
+    ({ 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

@@ -0,0 +1,22 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+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(mut p: *mut u64) {
+    (*p) = 42_u64;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut x: usize = 0_usize;
+    (unsafe { write_ulong_0((&mut x as *mut usize) as *mut u64) });
+    assert!(((((x) == (42_usize)) as i32) != 0));
+    return 0;
+}