Use ConvertPointeeType instead of Convert(t->getPointeeType())

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -86,6 +86,19 @@ bool Converter::ConvertMappedType(clang::QualType qual_type) {
   return true;
 }
 
+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);
+  }
+
+  auto str = ToString(ptr_type);
+  Unwrap(str, "*mut ", "");
+  Unwrap(str, "*const ", "");
+  return str;
+}
+
 bool Converter::VisitBuiltinType(clang::BuiltinType *type) {
   switch (type->getKind()) {
   case clang::BuiltinType::Bool:
@@ -216,9 +229,8 @@ bool Converter::VisitIncompleteArrayType(clang::IncompleteArrayType *type) {
 }
 
 bool Converter::VisitLValueReferenceType(clang::LValueReferenceType *type) {
-  StrCat(token::kStar);
   auto pointee_type = type->getPointeeType();
-  StrCat(pointee_type.isConstQualified() ? keyword::kConst : keyword_mut_);
+  StrCat(pointee_type.isConstQualified() ? "*const" : "*mut");
   return Convert(pointee_type);
 }
 
@@ -250,9 +262,8 @@ bool Converter::VisitPointerType(clang::PointerType *type) {
     return false;
   }
 
-  StrCat(token::kStar);
   auto pointee_type = type->getPointeeType();
-  StrCat(pointee_type.isConstQualified() ? keyword::kConst : keyword_mut_);
+  StrCat(pointee_type.isConstQualified() ? "*const" : "*mut");
   if (pointee_type->isRecordType() &&
       abstract_structs_.contains(GetID(pointee_type->getAsRecordDecl()))) {
     StrCat(keyword::kDyn);
@@ -1850,7 +1861,7 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     if (type->isVoidPointerType()) {
       StrCat(keyword::kAs,
              type->getPointeeType().isConstQualified() ? "*const" : "*mut");
-      Convert(sub_expr->getType()->getPointeeType());
+      StrCat(ConvertPointeeType(sub_expr->getType()));
     }
     ConvertCast(type);
     break;
@@ -2109,7 +2120,7 @@ void Converter::ConvertBinaryOperator(clang::BinaryOperator *expr) {
         StrCat(keyword::kAs, "usize");
       }
       StrCat(token::kDiv);
-      auto pointee_type_as_string = ToString(lhs_type->getPointeeType());
+      auto pointee_type_as_string = ConvertPointeeType(lhs_type);
       auto size_of_as_string =
           std::format("::std::mem::size_of::<{}>()", pointee_type_as_string);
       StrCat(size_of_as_string);

cpp2rust/converter/converter.h

@@ -398,6 +398,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual bool Convert(clang::QualType qual_type);
   virtual bool ConvertMappedType(clang::QualType qual_type);
 
+  virtual std::string ConvertPointeeType(clang::QualType ptr_type);
+
   virtual bool Convert(clang::Decl *decl);
   virtual bool Convert(clang::Stmt *stmt);
   virtual bool Convert(clang::Expr *expr);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1080,9 +1080,9 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
 
       if (pointee_type && abstract_structs_.contains(GetID(pointee_type))) {
         PushConversionKind push(*this, ConversionKind::Unboxed);
-        StrCat(std::format("({}.to_strong() as Value<dyn {}>).as_pointer_dyn()",
+        StrCat(std::format("({}.to_strong() as Value<{}>).as_pointer_dyn()",
                            ToString(sub_expr->IgnoreCasts()),
-                           ToString(expr->getType()->getPointeeType())));
+                           ConvertPointeeType(expr->getType())));
         computed_expr_type_ = ComputedExprType::FreshPointer;
         return false;
       }
@@ -1223,6 +1223,12 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
       StrCat(std::format(".cast::<{}>().expect(\"ub:wrong type\")",
                          ConvertPointeeType(expr->getType())));
       return false;
+    } else if (expr->getType()->isVoidPointerType() &&
+               expr->getSubExpr()->getType()->isPointerType()) {
+      StrCat(
+          std::format("{}.to_any()", ConvertFreshPointer(expr->getSubExpr())));
+      computed_expr_type_ = ComputedExprType::FreshPointer;
+      return false;
     } else if (expr->getSubExpr()->getType()->isPointerType() &&
                !expr->getSubExpr()->isNullPointerConstant(
                    ctx_, clang::Expr::NPC_ValueDependentIsNull)) {
@@ -2321,6 +2327,7 @@ std::string ConverterRefCount::ConvertPointeeType(clang::QualType ptr_type) {
   // not have a translation rule. Hence ToString(ptr_type->getPointeeType()) is
   // not enough
   auto str = ToString(ptr_type);
+  Unwrap(str, "PtrDyn<", ">");
   Unwrap(str, "Ptr<", ">");
   return str;
 }

cpp2rust/converter/models/converter_refcount.h

@@ -216,7 +216,7 @@ class ConverterRefCount final : public Converter {
   std::string ConvertFreshPointer(clang::Expr *expr) override;
 
   std::string ConvertPtrType(clang::QualType type);
-  std::string ConvertPointeeType(clang::QualType ptr_type);
+  std::string ConvertPointeeType(clang::QualType ptr_type) override;
 
   /// The kind of conversion that should be performed.
   enum class ConversionKind : uint8_t {

tests/unit/out/refcount/ptr_to_incomplete_struct.rs

@@ -0,0 +1,29 @@
+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 main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let fp: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new((libcc2rs::cout()).clone()));
+    let p: Value<AnyPtr> = Rc::new(RefCell::new((*fp.borrow()).clone().to_any()));
+    let fp2: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
+        ((*p.borrow())
+            .cast::<::std::fs::File>()
+            .expect("ub:wrong type"))
+        .clone(),
+    ));
+    assert!(
+        ((({
+            let _lhs = (*fp.borrow()).clone();
+            _lhs == (*fp2.borrow()).clone()
+        }) as i32)
+            != 0)
+    );
+    return 0;
+}

tests/unit/out/unsafe/ptr_to_incomplete_struct.rs

@@ -0,0 +1,20 @@
+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 fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut fp: *mut ::libc::FILE = libcc2rs::stdout_unsafe();
+    let mut p: *mut ::libc::c_void = (fp as *mut ::libc::c_void);
+    let mut fp2: *mut ::libc::FILE = (p as *mut ::libc::FILE);
+    assert!(((((fp) == (fp2)) as i32) != 0));
+    return 0;
+}

tests/unit/ptr_to_incomplete_struct.c

@@ -0,0 +1,10 @@
+#include <assert.h>
+#include <stdio.h>
+
+int main(void) {
+  FILE *fp = stdout;
+  void *p = (void *)fp;
+  FILE *fp2 = (FILE *)p;
+  assert(fp == fp2);
+  return 0;
+}