Fix #319: add reinterpret_cast for implicit pointer casts with different Rust types

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

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -2165,6 +2165,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())) {
@@ -2177,15 +2178,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/models/converter_refcount.cpp

@@ -1263,6 +1263,15 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   }
 
   if (expr->getCastKind() == clang::CastKind::CK_NoOp) {
+    if (expr->getType()->isPointerType() && sub_expr->getType()->isPointerType()) {
+      auto dest_type = ConvertPointeeType(expr->getType());
+      if (dest_type != ConvertPointeeType(sub_expr->getType())) {
+        Convert(sub_expr);
+        StrCat(std::format(".reinterpret_cast::<{}>()", dest_type));
+        computed_expr_type_ = ComputedExprType::FreshPointer;
+        return false;
+      }
+    }
     Convert(sub_expr);
     return false;
   }

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(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;
+}