Translat move ctors for records that have custom move ctors fields

Author: lucic71

cpp2rust/converter/converter_lib.cpp

@@ -528,12 +528,21 @@ IsConvertibleImplicitMemberParent(const clang::CXXRecordDecl *decl) {
          decl->getNumBases() == 0;
 }
 
+static bool HasFieldWithMoveFrom(const clang::RecordDecl *decl) {
+  return llvm::any_of(decl->fields(), [](const clang::FieldDecl *field) {
+    auto *record = field->getType()->getAsRecordDecl();
+    return record && HasMoveFromConstructor(record);
+  });
+}
+
 bool IsConvertibleMoveConstructor(const clang::CXXConstructorDecl *ctor) {
-  return ctor->isMoveConstructor() && !ctor->isDeleted() &&
-         IsConvertibleImplicitMemberParent(ctor->getParent()) &&
-         (ctor->isUserProvided() ||
-          !HasDefaultedCopyConstructor(ctor->getParent())) &&
-         ctor->hasBody();
+  auto *parent = ctor->getParent();
+  if (!ctor->isMoveConstructor() || ctor->isDeleted() || !ctor->hasBody() ||
+      !IsConvertibleImplicitMemberParent(parent)) {
+    return false;
+  }
+  return ctor->isUserProvided() || !HasDefaultedCopyConstructor(parent) ||
+         HasFieldWithMoveFrom(parent);
 }
 
 bool HasMoveFromConstructor(const clang::RecordDecl *decl) {
@@ -544,12 +553,23 @@ bool HasMoveFromConstructor(const clang::RecordDecl *decl) {
          });
 }
 
+static bool HasFieldWithMoveAssign(const clang::RecordDecl *decl) {
+  return llvm::any_of(decl->fields(), [](const clang::FieldDecl *field) {
+    auto *record = field->getType()->getAsCXXRecordDecl();
+    return record && llvm::any_of(record->methods(), [](auto *method) {
+             return IsConvertibleMoveAssignment(method);
+           });
+  });
+}
+
 bool IsConvertibleMoveAssignment(const clang::CXXMethodDecl *method) {
-  return method->isMoveAssignmentOperator() && !method->isDeleted() &&
-         IsConvertibleImplicitMemberParent(method->getParent()) &&
-         (method->isUserProvided() ||
-          !HasDefaultedCopyAssignment(method->getParent())) &&
-         method->hasBody();
+  auto *parent = method->getParent();
+  if (!method->isMoveAssignmentOperator() || method->isDeleted() ||
+      !method->hasBody() || !IsConvertibleImplicitMemberParent(parent)) {
+    return false;
+  }
+  return method->isUserProvided() || !HasDefaultedCopyAssignment(parent) ||
+         HasFieldWithMoveAssign(parent);
 }
 
 bool IsConvertibleImplicitMember(const clang::CXXMethodDecl *method) {

tests/unit/out/refcount/copy_ctor.rs

@@ -143,13 +143,20 @@ impl Clone for Box_int_ {
         Box_int_::copy_from(__src.as_pointer())
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
 #[byte_size(4)]
 pub struct Owner {
     #[offset(0)]
     #[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_) }),
+        }
+    }
+}
 #[derive(Record, ByteRepr, VaArg, FnPtrArg, Default)]
 #[byte_size(4)]
 pub struct OutOfLine {
@@ -272,7 +279,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 ol1: Value<OutOfLine> = Rc::new(RefCell::new(OutOfLine::new({ 5 })));
     let mut ol2: OutOfLine = OutOfLine::copy_from({ ol1.as_pointer() });

tests/unit/out/refcount/structured_binding_element_ctor.rs

@@ -44,7 +44,7 @@ impl Clone for Elem {
         Elem::copy_from(__src.as_pointer())
     }
 }
-#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, MoveCtor, Default)]
 #[byte_size(8)]
 pub struct Two {
     #[offset(0)]
@@ -54,6 +54,14 @@ pub struct Two {
     #[byte_size(4)]
     pub b: Elem,
 }
+impl Two {
+    pub fn move_from(_a0: Ptr<Two>) -> Self {
+        Self {
+            a: Elem::move_from({ field_ptr!(_a0, a) }),
+            b: Elem::move_from({ field_ptr!(_a0, b) }),
+        }
+    }
+}
 pub fn make_two_2() -> Two {
     return Two {
         a: Elem::new({ 1 }),
@@ -81,7 +89,7 @@ fn main_0() -> i32 {
     assert!(({ (*__decomp_4.upgrade().deref()).a.v } == 1));
     field!(field!(__decomp_4, a), v).write(50);
     assert!(({ (*t.borrow()).a.v } == 50));
-    let __decomp_5: Value<Two> = Rc::new(RefCell::new((*t.borrow()).clone()));
+    let __decomp_5: Value<Two> = Rc::new(RefCell::new(Two::move_from({ t.as_pointer() })));
     assert!((moves_1.with(|rc| *rc.borrow()) == (base_moves + 2)));
     assert!(({ (*__decomp_5.borrow()).a.v } == 1050));
     assert!(({ (*__decomp_5.borrow()).b.v } == 1002));

tests/unit/out/unsafe/copy_ctor.rs

@@ -113,10 +113,18 @@ impl Clone for Box_int_ {
     }
 }
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, Default)]
+#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
 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
+    }
+}
 #[repr(C)]
 #[derive(VaArg, FnPtrArg, Default)]
 pub struct OutOfLine {
@@ -226,7 +234,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 ol1: OutOfLine = OutOfLine::new({ 5 });
     let mut ol2: OutOfLine = OutOfLine::copy_from({ &ol1 });

tests/unit/out/unsafe/structured_binding_element_ctor.rs

@@ -40,11 +40,20 @@ impl Clone for Elem {
     }
 }
 #[repr(C)]
-#[derive(Clone, VaArg, FnPtrArg, Default)]
+#[derive(Clone, VaArg, FnPtrArg, MoveCtorUnsafe, Default)]
 pub struct Two {
     pub a: Elem,
     pub b: Elem,
 }
+impl Two {
+    pub unsafe fn move_from(_a0: *mut Two) -> Self {
+        let mut this = Self {
+            a: Elem::move_from({ &mut (*_a0).a }),
+            b: Elem::move_from({ &mut (*_a0).b }),
+        };
+        this
+    }
+}
 pub unsafe fn make_two_2() -> Two {
     return Two {
         a: Elem::new({ 1 }),
@@ -74,7 +83,7 @@ unsafe fn main_0() -> i32 {
     assert!((((*__decomp_4).a.v) == (1)));
     (*__decomp_4).a.v = 50;
     assert!(((t.a.v) == (50)));
-    let mut __decomp_5: Two = t.clone();
+    let mut __decomp_5: Two = Two::move_from({ &mut t });
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_1)) == ((base_moves) + (2))));
     assert!(((__decomp_5.a.v) == (1050)));
     assert!(((__decomp_5.b.v) == (1002)));