Derive VaArg and FnPtrArg for cloneable records (#432)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -92,7 +92,7 @@ void Converter::EmitGlobalInits(Model model, std::string &out) {
 
 void Converter::EmitOpaqueRecords(std::string &out) {
   record_decls_.ForEachUndefined([&](const std::string &name) {
-    out += "#[derive(Clone, Copy, Default, ByteRepr)]";
+    out += "#[derive(Clone, Copy, Default, ByteRepr, VaArg, FnPtrArg)]";
     out += "pub struct ";
     out += name;
     out += ";\n";
@@ -4147,6 +4147,10 @@ Converter::GetStructAttributes(const clang::RecordDecl *decl) {
     struct_attrs.emplace_back("Clone");
   }
 
+  if (RecordImplementsClone(decl)) {
+    struct_attrs.emplace_back("VaArg");
+  }
+
   if (RecordDerivesDefault(decl)) {
     struct_attrs.emplace_back("Default");
   }
@@ -4637,6 +4641,11 @@ void Converter::AddCloneTrait(const clang::RecordDecl *decl) {
                          : std::format(" as *mut {}", record_name)));
 }
 
+bool Converter::RecordImplementsClone(const clang::RecordDecl *decl) {
+  return HasDefaultedCopyConstructor(decl) ||
+         GetUserDefinedCopyConstructor(decl) != nullptr;
+}
+
 void Converter::AddDefaultTraitForUnion(const clang::RecordDecl *decl) {
   StrCat(std::format("impl Default for {}", GetRecordName(decl)));
   PushBrace impl_brace(*this);

cpp2rust/converter/converter.h

@@ -660,6 +660,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void AddCloneTrait(const clang::RecordDecl *decl);
 
+  virtual bool RecordImplementsClone(const clang::RecordDecl *decl);
+
   virtual void AddDefaultTrait(const clang::RecordDecl *decl);
 
   virtual void AddDefaultTraitForUnion(const clang::RecordDecl *decl);

cpp2rust/converter/models/converter_refcount.cpp

@@ -469,6 +469,15 @@ std::string ConverterRefCount::GetShallowCopy(const clang::RecordDecl *decl,
   return std::format("{} {{ {} }}", GetRecordName(decl), fields);
 }
 
+bool ConverterRefCount::RecordImplementsClone(const clang::RecordDecl *decl) {
+  if (decl->isUnion() || (HasDefaultedCopyConstructor(decl) &&
+                          RecordHasOnlyReferenceFields(decl))) {
+    return true;
+  }
+  return !clang::isa<clang::CXXRecordDecl>(decl) ||
+         HasCallableCopyConstructor(decl);
+}
+
 void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
   auto record_name = GetRecordName(decl);
 
@@ -501,7 +510,7 @@ void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
     return;
   }
 
-  if (!HasCallableCopyConstructor(cxx)) {
+  if (!RecordImplementsClone(decl)) {
     return;
   }
 
@@ -2053,6 +2062,10 @@ bool ConverterRefCount::VisitCXXScalarValueInitExpr(
 }
 
 void ConverterRefCount::ConvertVariadicArg(clang::Expr *arg) {
+  if (arg->getType()->isRecordType()) {
+    StrCat(ConvertFreshRValue(arg));
+    return;
+  }
   if (arg->getType()->isPointerType()) {
     StrCat(ConvertFreshPointer(arg));
     return;
@@ -2160,6 +2173,11 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
     attrs.emplace_back("ByteRepr");
   }
 
+  if (RecordImplementsClone(decl)) {
+    attrs.emplace_back("VaArg");
+    attrs.emplace_back("FnPtrArg");
+  }
+
   if (RecordDerivesDefault(decl)) {
     attrs.emplace_back("Default");
   }

cpp2rust/converter/models/converter_refcount.h

@@ -49,6 +49,8 @@ class ConverterRefCount final : public Converter {
                              std::string_view src);
   void AddCloneTrait(const clang::RecordDecl *decl) override;
 
+  bool RecordImplementsClone(const clang::RecordDecl *decl) override;
+
   void AddByteReprTrait(const clang::RecordDecl *decl) override;
 
   bool

libcc2rs-macros/src/fn_ptr_arg.rs

@@ -0,0 +1,23 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use syn::{DeriveInput, parse_macro_input};
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    quote::quote! {
+        impl #impl_generics ::libcc2rs::FnPtrArg for #name #ty_generics #where_clause {
+            #[inline]
+            fn to_repr(&self) -> ::libcc2rs::ArgRepr<'_> {
+                ::libcc2rs::ArgRepr::Record(self)
+            }
+            fn from_repr(r: &::libcc2rs::ArgRepr) -> Self {
+                ::libcc2rs::record_from_repr(r)
+            }
+        }
+    }
+    .into()
+}

libcc2rs-macros/src/lib.rs

@@ -4,9 +4,11 @@
 use proc_macro::TokenStream;
 
 mod byte_repr;
+mod fn_ptr_arg;
 mod goto;
 mod state_machine;
 mod switch;
+mod va_arg;
 
 //     switch!(match <condition> {
 //         <pat> [if <guard>] => { /* body; may contain break or continue */ },
@@ -91,3 +93,13 @@ pub fn goto(_input: TokenStream) -> TokenStream {
 pub fn derive_byte_repr(input: TokenStream) -> TokenStream {
     byte_repr::expand(input)
 }
+
+#[proc_macro_derive(VaArg)]
+pub fn derive_va_arg(input: TokenStream) -> TokenStream {
+    va_arg::expand(input)
+}
+
+#[proc_macro_derive(FnPtrArg)]
+pub fn derive_fn_ptr_arg(input: TokenStream) -> TokenStream {
+    fn_ptr_arg::expand(input)
+}

libcc2rs-macros/src/va_arg.rs

@@ -0,0 +1,27 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use syn::{DeriveInput, parse_macro_input};
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    quote::quote! {
+        impl #impl_generics ::core::convert::From<#name #ty_generics> for ::libcc2rs::VaArg
+        #where_clause
+        {
+            fn from(v: #name #ty_generics) -> Self {
+                ::libcc2rs::VaArg::Record(::std::rc::Rc::new(v))
+            }
+        }
+
+        impl #impl_generics ::libcc2rs::VaArgGet for #name #ty_generics #where_clause {
+            fn get(v: &::libcc2rs::VaArg) -> Self {
+                ::libcc2rs::va_record_get(v)
+            }
+        }
+    }
+    .into()
+}

libcc2rs/src/fn_ptr_arg.rs

@@ -4,18 +4,21 @@
 // Support for FnPtr::cast synthesizing a call-through adapter automatically,
 // for any function pointer types T -> U.
 
+use std::any::Any;
+
 use crate::rc::Ptr;
 use crate::reinterpret::ByteRepr;
 use crate::void::{AnyPtr, ErasedPtr};
 
 // A type-erased view of one argument or return value, used only transiently
 // (within a single adapted call) and never allocated.
-pub(crate) enum ArgRepr<'a> {
+pub enum ArgRepr<'a> {
     Bytes([u8; 16], usize),
     Ptr(&'a dyn ErasedPtr),
+    Record(&'a dyn Any),
 }
 
-pub(crate) trait FnPtrArg: 'static {
+pub trait FnPtrArg: 'static {
     fn to_repr(&self) -> ArgRepr<'_>;
     // Panics if `r` describes a value that isn't a meaningful `Self` (wrong
     // kind, or same kind but incompatible size).
@@ -105,7 +108,9 @@ impl<T: ByteRepr> FnPtrArg for Ptr<T> {
                 Some(exact) => exact.clone(),
                 None => e.as_bytes().reinterpret_cast(),
             },
-            ArgRepr::Bytes(..) => panic!("ub: calling through incompatible fn pointer type"),
+            ArgRepr::Bytes(..) | ArgRepr::Record(_) => {
+                panic!("ub: calling through incompatible fn pointer type")
+            }
         }
     }
 }
@@ -118,11 +123,23 @@ impl FnPtrArg for AnyPtr {
     fn from_repr(r: &ArgRepr) -> Self {
         match r {
             ArgRepr::Ptr(e) => e.as_bytes().to_any(),
-            ArgRepr::Bytes(..) => panic!("ub: calling through incompatible fn pointer type"),
+            ArgRepr::Bytes(..) | ArgRepr::Record(_) => {
+                panic!("ub: calling through incompatible fn pointer type")
+            }
         }
     }
 }
 
+pub fn record_from_repr<T: Any + Clone>(r: &ArgRepr) -> T {
+    match r {
+        ArgRepr::Record(v) => v
+            .downcast_ref::<T>()
+            .expect("ub: calling through incompatible fn pointer type")
+            .clone(),
+        _ => panic!("ub: calling through incompatible fn pointer type"),
+    }
+}
+
 // Fixed-capacity, type-erased view of a whole argument list: `FnPtrArgs`
 // (below) converts a tuple of arguments to and from this common
 // intermediate, so that converting between two argument lists never needs to

libcc2rs/src/format.rs

@@ -62,7 +62,7 @@ pub fn format_c(fmt: &str, va: &[VaArg]) -> String {
                     VaArg::ULong(v) => Arg::ULong(*v),
                     VaArg::Ptr(p) => Arg::Size(p.to_int()),
                     VaArg::RawPtr(v) => Arg::Size(*v as usize),
-                    VaArg::Double(_) => {
+                    VaArg::Double(_) | VaArg::Record(_) => {
                         panic!("format_c: integer conversion expects an integer argument")
                     }
                 },

libcc2rs/src/lib.rs

@@ -18,6 +18,7 @@ pub use ptr_dyn::*;
 include!(concat!(env!("OUT_DIR"), "/rule_shims.rs"));
 
 mod fn_ptr_arg;
+pub use fn_ptr_arg::{ArgRepr, FnPtrArg, record_from_repr};
 
 mod fn_ptr;
 pub use fn_ptr::FnPtr;
@@ -55,4 +56,4 @@ pub use fd::*;
 mod format;
 pub use format::*;
 
-pub use libcc2rs_macros::{ByteRepr, goto, goto_block, switch};
+pub use libcc2rs_macros::{ByteRepr, FnPtrArg, VaArg, goto, goto_block, switch};