Add a DeepClone macro to remove manual Clone implementations

FIxes #216

Author: nunoplopes

cpp2rust/converter/models/converter_refcount.cpp

@@ -540,45 +540,28 @@ bool ConverterRefCount::RecordDerivesClone(const clang::RecordDecl *decl) {
   });
 }
 
-void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
-  auto record_name = GetRecordName(decl);
-
+bool ConverterRefCount::RecordDerivesDeepClone(const clang::RecordDecl *decl) {
   if (decl->isUnion()) {
-    StrCat("impl Clone for", record_name);
-    PushBrace impl_brace(*this);
-    StrCat("fn clone(&self) -> Self");
-    PushBrace fn_brace(*this);
-    StrCat(record_name,
-           "{ __bytes: Rc::new(RefCell::new(self.__bytes.borrow().clone())) }");
-    return;
+    return true;
   }
-
   if (RecordDerivesClone(decl) || !RecordImplementsClone(decl)) {
-    return;
+    return false;
   }
   // Without a user-defined copy constructor, each field is copied with its
   // own clone(), and Values are copied deeply.
   auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
-  if (!cxx ||
-      (!GetUserDefinedCopyConstructor(cxx) && cxx->getNumBases() == 0)) {
-    StrCat(keyword::kImpl, "Clone for", record_name);
-    PushBrace impl_brace(*this);
-    StrCat("fn clone(&self) -> Self");
-    PushBrace fn_brace(*this);
-    StrCat("Self");
-    PushBrace init_brace(*this);
-    for (auto *field : decl->fields()) {
-      auto name = GetNamedDeclAsString(field);
-      auto value = std::format("self.{}.clone()", name);
-      if (IsValueField(ctx_, field)) {
-        value = std::format(
-            "Rc::new(RefCell::new((*self.{}.borrow()).clone()))", name);
-      }
-      StrCat(std::format("{}: {},", name, value));
-    }
+  return !cxx ||
+         (!GetUserDefinedCopyConstructor(cxx) && cxx->getNumBases() == 0);
+}
+
+void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
+  if (RecordDerivesClone(decl) || RecordDerivesDeepClone(decl) ||
+      !RecordImplementsClone(decl)) {
     return;
   }
 
+  auto record_name = GetRecordName(decl);
+  auto *cxx = clang::cast<clang::CXXRecordDecl>(decl);
   StrCat(keyword::kImpl, "Clone for", record_name, '{');
   StrCat("fn clone(&self) -> Self {");
 
@@ -627,10 +610,10 @@ void ConverterRefCount::EmitRustUnion(clang::RecordDecl *decl) {
       std::vector<std::string>(attrs.begin(), attrs.end()));
 
   auto size = ctx_.getTypeSizeInChars(ctx_.getCanonicalTagType(decl));
-  StrCat(std::format("#[derive(ByteRepr)] #[byte_size({0})] pub struct {1} {{ "
-                     "#[offset(0)] #[byte_size({0})] __bytes: Value<Box<[u8]>> "
-                     "}}",
-                     size.getQuantity(), name));
+  StrCat(std::format(
+      "#[derive(ByteRepr, DeepClone)] #[byte_size({0})] pub struct {1} {{ "
+      "#[offset(0)] #[byte_size({0})] __bytes: Value<Box<[u8]>> }}",
+      size.getQuantity(), name));
 
   StrCat("impl", name);
   {
@@ -2292,6 +2275,8 @@ ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
 
   if (RecordDerivesClone(decl)) {
     attrs.emplace_back("Clone");
+  } else if (RecordDerivesDeepClone(decl)) {
+    attrs.emplace_back("DeepClone");
   }
 
   // Gives access to the fields through pointers to them.

cpp2rust/converter/models/converter_refcount.h

@@ -53,6 +53,8 @@ class ConverterRefCount final : public Converter {
 
   bool RecordDerivesClone(const clang::RecordDecl *decl);
 
+  bool RecordDerivesDeepClone(const clang::RecordDecl *decl);
+
   void EmitByteSizeAttr(const clang::RecordDecl *decl) override;
 
   bool

libcc2rs-macros/src/deep_clone.rs

@@ -0,0 +1,62 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, Index, Type, parse_macro_input};
+
+// Whether `ty` is a Value<_>, which is copied with DeepClone.
+fn is_value(ty: &Type) -> bool {
+    match ty {
+        Type::Path(path) => path
+            .path
+            .segments
+            .last()
+            .is_some_and(|segment| segment.ident == "Value"),
+        _ => false,
+    }
+}
+
+fn clone_field(ty: &Type, field: TokenStream2) -> TokenStream2 {
+    if is_value(ty) {
+        quote! { ::libcc2rs::DeepClone::deep_clone(&self.#field) }
+    } else {
+        quote! { ::core::clone::Clone::clone(&self.#field) }
+    }
+}
+
+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();
+    let Data::Struct(data) = &input.data else {
+        panic!("derive(DeepClone) is only supported on structs, `{name}` is not one");
+    };
+    let body = match &data.fields {
+        Fields::Named(fields) => {
+            let fields = fields.named.iter().map(|field| {
+                let ident = field.ident.as_ref().unwrap();
+                let value = clone_field(&field.ty, quote! { #ident });
+                quote! { #ident: #value }
+            });
+            quote! { Self { #(#fields,)* } }
+        }
+        Fields::Unnamed(fields) => {
+            let fields = fields.unnamed.iter().enumerate().map(|(i, field)| {
+                let index = Index::from(i);
+                clone_field(&field.ty, quote! { #index })
+            });
+            quote! { Self(#(#fields,)*) }
+        }
+        Fields::Unit => quote! { Self },
+    };
+    quote! {
+        impl #impl_generics ::core::clone::Clone for #name #ty_generics #where_clause {
+            fn clone(&self) -> Self {
+                #body
+            }
+        }
+    }
+    .into()
+}

libcc2rs-macros/src/lib.rs

@@ -4,6 +4,7 @@
 use proc_macro::TokenStream;
 
 mod byte_repr;
+mod deep_clone;
 mod fn_ptr_arg;
 mod goto;
 mod record;
@@ -131,3 +132,18 @@ pub fn derive_fn_ptr_arg(input: TokenStream) -> TokenStream {
 pub fn derive_record(input: TokenStream) -> TokenStream {
     record::expand(input)
 }
+
+//     #[derive(DeepClone)]
+//     pub struct S {
+//         pub x: Value<T>,
+//         pub y: U,
+//     }
+//
+// Implements Clone for S, copying the Value fields with
+// libcc2rs::DeepClone, such that the copy of S doesn't share them with S,
+// and the other fields with Clone.
+
+#[proc_macro_derive(DeepClone)]
+pub fn derive_deep_clone(input: TokenStream) -> TokenStream {
+    deep_clone::expand(input)
+}

libcc2rs/src/lib.rs

@@ -69,4 +69,4 @@ pub use fd::*;
 mod format;
 pub use format::*;
 
-pub use libcc2rs_macros::{ByteRepr, FnPtrArg, Record, VaArg, goto, goto_block, switch};
+pub use libcc2rs_macros::{ByteRepr, DeepClone, FnPtrArg, Record, VaArg, goto, goto_block, switch};

libcc2rs/src/rc.rs

@@ -16,6 +16,19 @@ use crate::reinterpret::{ByteRepr, OriginalAlloc, with_scratch};
 
 pub type Value<T> = Rc<RefCell<T>>;
 
+// A copy of a Value that doesn't share the value: unlike clone(), which
+// shares it by incrementing the reference count, it copies the value into a
+// new Value.
+pub trait DeepClone {
+    fn deep_clone(&self) -> Self;
+}
+
+impl<T: Clone> DeepClone for Value<T> {
+    fn deep_clone(&self) -> Self {
+        Rc::new(RefCell::new(self.borrow().clone()))
+    }
+}
+
 pub(crate) struct ReinterpretedView {
     // Pointer to the source of reinterpret
     pub(crate) alloc: OriginalAlloc,

rules/dirent/shim.rs

@@ -1,12 +1,12 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{ByteRepr, Record, Value, size_of_field};
+use crate::{ByteRepr, DeepClone, Record, Value, size_of_field};
 use std::cell::{Cell, RefCell};
 use std::mem::{offset_of, size_of};
 use std::rc::Rc;
 
-#[derive(Record, ByteRepr)]
+#[derive(DeepClone, Record, ByteRepr)]
 #[byte_size(size_of::<::libc::dirent>())]
 pub struct Dirent {
     #[offset(offset_of!(::libc::dirent, d_ino))]
@@ -54,15 +54,6 @@ impl Dirent {
     }
 }
 
-impl Clone for Dirent {
-    fn clone(&self) -> Self {
-        Self {
-            d_name: Rc::new(RefCell::new(self.d_name.borrow().clone())),
-            ..*self
-        }
-    }
-}
-
 pub struct CDir {
     pub entries: Vec<(u64, Vec<u8>, u8)>,
     pub pos: Cell<usize>,

rules/ip/shim.rs

@@ -1,7 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{AsPointer, ByteRepr, Ptr, Record, Value};
+use crate::{AsPointer, ByteRepr, DeepClone, Ptr, Record, Value};
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -12,7 +12,7 @@ pub struct InAddr {
     pub s_addr: u32,
 }
 
-#[derive(Record, ByteRepr)]
+#[derive(DeepClone, Record, ByteRepr)]
 #[byte_size(16)]
 pub struct In6Addr {
     #[offset(0)]
@@ -34,13 +34,5 @@ impl Default for In6Addr {
     }
 }
 
-impl Clone for In6Addr {
-    fn clone(&self) -> Self {
-        Self {
-            s6_addr: Rc::new(RefCell::new(self.s6_addr.borrow().clone())),
-        }
-    }
-}
-
 impl ByteRepr for ::libc::in_addr {}
 impl ByteRepr for ::libc::in6_addr {}

rules/socket/shim.rs

@@ -1,12 +1,12 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{ByteRepr, In6Addr, InAddr, Ptr, Record, Value};
+use crate::{ByteRepr, DeepClone, In6Addr, InAddr, Ptr, Record, Value};
 use std::cell::RefCell;
 use std::rc::Rc;
 
 // The fields are at the offsets of the byte representation below.
-#[derive(Record, ByteRepr)]
+#[derive(DeepClone, Record, ByteRepr)]
 #[byte_size(16)]
 pub struct Sockaddr {
     #[offset(0)]
@@ -16,7 +16,7 @@ pub struct Sockaddr {
     pub sa_data: Value<Box<[u8]>>,
 }
 
-#[derive(Record, ByteRepr)]
+#[derive(DeepClone, Record, ByteRepr)]
 #[byte_size(16)]
 pub struct SockaddrIn {
     #[offset(0)]
@@ -30,7 +30,7 @@ pub struct SockaddrIn {
     pub sin_zero: Value<Box<[u8]>>,
 }
 
-#[derive(Default, Record, ByteRepr)]
+#[derive(Clone, Default, Record, ByteRepr)]
 #[byte_size(28)]
 pub struct SockaddrIn6 {
     #[offset(0)]
@@ -45,7 +45,7 @@ pub struct SockaddrIn6 {
     pub sin6_scope_id: u32,
 }
 
-#[derive(Record, ByteRepr)]
+#[derive(DeepClone, Record, ByteRepr)]
 #[byte_size(110)]
 pub struct SockaddrUn {
     #[offset(0)]
@@ -55,7 +55,7 @@ pub struct SockaddrUn {
     pub sun_path: Value<Box<[u8]>>,
 }
 
-#[derive(Record, ByteRepr)]
+#[derive(DeepClone, Record, ByteRepr)]
 #[byte_size(128)]
 pub struct SockaddrStorage {
     #[offset(0)]
@@ -222,56 +222,6 @@ impl Default for SockaddrStorage {
     }
 }
 
-impl Clone for Sockaddr {
-    fn clone(&self) -> Self {
-        Self {
-            sa_family: self.sa_family,
-            sa_data: Rc::new(RefCell::new(self.sa_data.borrow().clone())),
-        }
-    }
-}
-
-impl Clone for SockaddrIn {
-    fn clone(&self) -> Self {
-        Self {
-            sin_family: self.sin_family,
-            sin_port: self.sin_port,
-            sin_addr: self.sin_addr.clone(),
-            sin_zero: Rc::new(RefCell::new(self.sin_zero.borrow().clone())),
-        }
-    }
-}
-
-impl Clone for SockaddrIn6 {
-    fn clone(&self) -> Self {
-        Self {
-            sin6_family: self.sin6_family,
-            sin6_port: self.sin6_port,
-            sin6_flowinfo: self.sin6_flowinfo,
-            sin6_addr: self.sin6_addr.clone(),
-            sin6_scope_id: self.sin6_scope_id,
-        }
-    }
-}
-
-impl Clone for SockaddrUn {
-    fn clone(&self) -> Self {
-        Self {
-            sun_family: self.sun_family,
-            sun_path: Rc::new(RefCell::new(self.sun_path.borrow().clone())),
-        }
-    }
-}
-
-impl Clone for SockaddrStorage {
-    fn clone(&self) -> Self {
-        Self {
-            ss_family: self.ss_family,
-            __pad: Rc::new(RefCell::new(self.__pad.borrow().clone())),
-        }
-    }
-}
-
 impl ByteRepr for ::libc::sockaddr {}
 impl ByteRepr for ::libc::sockaddr_in {}
 impl ByteRepr for ::libc::sockaddr_in6 {}