Use implicit move ctor when copy ctor is not aavilable

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -4271,13 +4271,11 @@ Converter::GetStructAttributes(const clang::RecordDecl *decl) {
 
   std::vector<const char *> struct_attrs;
 
-  bool derives_clone =
-      HasDefaultedCopyConstructor(decl) && RecordImplementsClone(decl);
-  if (derives_clone && RecordHasCopyableFields(decl)) {
+  if (HasDefaultedCopyConstructor(decl) && RecordHasCopyableFields(decl)) {
     struct_attrs.emplace_back("Copy");
   }
 
-  if (derives_clone) {
+  if (HasDefaultedCopyConstructor(decl)) {
     struct_attrs.emplace_back("Clone");
   }
 
@@ -4764,16 +4762,8 @@ void Converter::AddCloneTrait(const clang::RecordDecl *decl) {
 }
 
 bool Converter::RecordImplementsClone(const clang::RecordDecl *decl) {
-  if (GetUserDefinedCopyConstructor(decl)) {
-    return HasCallableCopyConstructor(decl);
-  }
-  return HasDefaultedCopyConstructor(decl) &&
-         std::ranges::all_of(decl->fields(), [&](const clang::FieldDecl *f) {
-           auto *record =
-               ctx_.getBaseElementType(f->getType())->getAsCXXRecordDecl();
-           return !record || !IsUserDefinedDecl(record) ||
-                  RecordImplementsClone(record);
-         });
+  return HasDefaultedCopyConstructor(decl) ||
+         GetUserDefinedCopyConstructor(decl) != nullptr;
 }
 
 void Converter::AddDefaultTraitForUnion(const clang::RecordDecl *decl) {

cpp2rust/converter/converter_lib.cpp

@@ -502,17 +502,28 @@ GetUserDefinedCopyConstructor(const clang::RecordDecl *decl) {
   return nullptr;
 }
 
+static bool FieldsHaveCallableCopyConstructors(const clang::RecordDecl *decl) {
+  auto &ctx = decl->getASTContext();
+  return std::ranges::all_of(decl->fields(), [&](const clang::FieldDecl *f) {
+    auto *record = ctx.getBaseElementType(f->getType())->getAsCXXRecordDecl();
+    return !record || !IsUserDefinedDecl(record) ||
+           HasCallableCopyConstructor(record);
+  });
+}
+
 bool HasDefaultedCopyConstructor(const clang::RecordDecl *decl) {
   auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
   if (!cxx) {
     return true;
   }
   for (const auto *ctor : cxx->ctors()) {
     if (ctor->isCopyConstructor()) {
-      return !ctor->isUserProvided() && !ctor->isDeleted();
+      return !ctor->isUserProvided() && !ctor->isDeleted() &&
+             FieldsHaveCallableCopyConstructors(cxx);
     }
   }
-  return !cxx->defaultedCopyConstructorIsDeleted();
+  return !cxx->defaultedCopyConstructorIsDeleted() &&
+         FieldsHaveCallableCopyConstructors(cxx);
 }
 
 bool RecordHasOnlyReferenceFields(const clang::RecordDecl *decl) {
@@ -543,7 +554,7 @@ bool HasCallableCopyConstructor(const clang::RecordDecl *decl) {
     return true;
   }
   if (!cxx->hasUserDeclaredCopyConstructor()) {
-    return !cxx->defaultedCopyConstructorIsDeleted();
+    return HasDefaultedCopyConstructor(cxx);
   }
   for (const auto *ctor : cxx->ctors()) {
     if (ctor->isCopyConstructor() && !ctor->isDeleted() &&

cpp2rust/converter/models/converter_refcount.cpp

@@ -603,13 +603,7 @@ bool ConverterRefCount::RecordImplementsClone(const clang::RecordDecl *decl) {
     return true;
   }
   return !clang::isa<clang::CXXRecordDecl>(decl) ||
-         (HasCallableCopyConstructor(decl) &&
-          std::ranges::all_of(decl->fields(), [&](const clang::FieldDecl *f) {
-            auto *record =
-                ctx_.getBaseElementType(f->getType())->getAsCXXRecordDecl();
-            return !record || !IsUserDefinedDecl(record) ||
-                   RecordImplementsClone(record);
-          }));
+         HasCallableCopyConstructor(decl);
 }
 
 // Bases are translated to traits, so they hold no state of the struct; they
@@ -629,7 +623,7 @@ bool ConverterRefCount::RecordDerivesClone(const clang::RecordDecl *decl) {
   // The copy of a struct copies each field, which a derived Clone does too,
   // except for Values, which it shares.
   auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
-  if (decl->isUnion() || (cxx && (!RecordImplementsClone(cxx) ||
+  if (decl->isUnion() || (cxx && (!HasCallableCopyConstructor(cxx) ||
                                   GetUserDefinedCopyConstructor(cxx) ||
                                   !HasDefaultedBaseCopies(cxx)))) {
     return false;

tests/unit/out/refcount/copy_ctor.rs

@@ -135,6 +135,13 @@ pub struct Owner {
     #[byte_size(4)]
     pub box_: Box_int_,
 }
+impl Owner {
+    pub fn move_from(_a0: Ptr<Owner>) -> Self {
+        Self {
+            box_: Box_int_::move_from({ field_ptr!(_a0, box_) }),
+        }
+    }
+}
 pub fn by_value_1(mut c: Counted) -> i32 {
     return c.v;
 }
@@ -203,7 +210,7 @@ fn main_0() -> i32 {
     let o: Value<Owner> = Rc::new(RefCell::new(Owner {
         box_: Box_int_::new({ 3 }),
     }));
-    let mut o2: Owner = (*o.borrow()).clone();
+    let mut o2: Owner = Owner::move_from({ o.as_pointer() });
     assert!((o2.box_.val == 3));
     let n: Value<NonConst> = Rc::new(RefCell::new(NonConst::new()));
     let mut n1: NonConst = NonConst::new_1({ n.as_pointer() });

tests/unit/out/unsafe/copy_ctor.rs

@@ -108,6 +108,14 @@ impl Box_int_ {
 pub struct Owner {
     pub box_: Box_int_,
 }
+impl Owner {
+    pub unsafe fn move_from(_a0: *mut Owner) -> Self {
+        let mut this = Self {
+            box_: Box_int_::move_from({ &mut (*_a0).box_ }),
+        };
+        this
+    }
+}
 pub unsafe fn by_value_1(mut c: Counted) -> i32 {
     return c.v;
 }
@@ -164,7 +172,7 @@ unsafe fn main_0() -> i32 {
     let mut o: Owner = Owner {
         box_: Box_int_::new({ 3 }),
     };
-    let mut o2: Owner = o.clone();
+    let mut o2: Owner = Owner::move_from({ &mut o });
     assert!(((o2.box_.val) == (3)));
     let mut n: NonConst = NonConst::new();
     let mut n1: NonConst = NonConst::new_1({ &mut n });