Use copy_from/move_from to translate copy/move ctor (#418)

If possible, use the `copy_from`/`move_from` idiomatic name instead of
`S_pmutS_rv`. This is only possible when the copy/move constructor is
unique (no other copy/move constructor exists) and when no other method
in the class is called copy_from/move_from.

Do the same for copy/move assignment: copy_assign and move_assign.

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1095,6 +1095,10 @@ std::string Converter::GetMethodName(const clang::CXXMethodDecl *decl) {
   if (clang::isa<clang::CXXDestructorDecl>(decl)) {
     return kDestructorName;
   }
+  if (const char *name = GetCopyOrMoveName(decl);
+      name && CanUseCopyOrMoveName(decl, name)) {
+    return name;
+  }
   if (IsOverloadedMethod(decl)) {
     return GetOverloadedFunctionName(decl);
   }
@@ -1144,6 +1148,10 @@ std::string Converter::GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl) {
 
 std::string Converter::GetCtorName(clang::CXXConstructorDecl *decl) {
   if (decl->isCopyOrMoveConstructor()) {
+    if (const char *name = GetCopyOrMoveName(decl);
+        CanUseCopyOrMoveName(decl, name)) {
+      return name;
+    }
     return GetOverloadedFunctionName(decl);
   }
   return GetNumberOfConvertingCtors(decl->getParent()) != 1
@@ -3342,7 +3350,7 @@ void Converter::ConvertMemberExpr(clang::MemberExpr *expr) {
   if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(member);
       method && IsOverloadedMethod(method)) {
     StrCat(token::kDot);
-    StrCat(GetOverloadedFunctionName(method));
+    StrCat(GetMethodName(method));
   } else if (!name_override.empty()) {
     StrCat(token::kDot, name_override);
   } else if (member->getDeclName().isIdentifier()) {

cpp2rust/converter/converter_lib.cpp

@@ -286,6 +286,44 @@ bool IsOverloadedMethod(const clang::CXXMethodDecl *decl) {
                        }) > 1;
 }
 
+const char *GetCopyOrMoveName(const clang::CXXMethodDecl *method) {
+  if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(method)) {
+    if (ctor->isCopyConstructor()) {
+      return "copy_from";
+    }
+    if (ctor->isMoveConstructor()) {
+      return "move_from";
+    }
+    return nullptr;
+  }
+  if (method->isCopyAssignmentOperator()) {
+    return "copy_assign";
+  }
+  if (method->isMoveAssignmentOperator()) {
+    return "move_assign";
+  }
+  return nullptr;
+}
+
+bool CanUseCopyOrMoveName(const clang::CXXMethodDecl *decl,
+                          const std::string &name) {
+  const auto *record = decl->getParent();
+  bool is_unique_member =
+      std::count_if(record->method_begin(), record->method_end(),
+                    [&name](const clang::CXXMethodDecl *method) {
+                      const char *method_name = GetCopyOrMoveName(method);
+                      return !method->isDeleted() && method_name &&
+                             method_name == name;
+                    }) == 1;
+  bool is_unique_name =
+      std::none_of(record->method_begin(), record->method_end(),
+                   [&name](const clang::CXXMethodDecl *method) {
+                     return method->getDeclName().isIdentifier() &&
+                            method->getName() == name;
+                   });
+  return is_unique_member && is_unique_name;
+}
+
 bool IsUserDefinedCopyConstructor(const clang::CXXConstructorDecl *ctor) {
   return ctor->isCopyConstructor() && ctor->isUserProvided() &&
          IsUserDefinedDecl(ctor);

cpp2rust/converter/converter_lib.h

@@ -70,6 +70,11 @@ void ForEachTemplateInstantiatedMethod(
 
 bool IsOverloadedMethod(const clang::CXXMethodDecl *decl);
 
+const char *GetCopyOrMoveName(const clang::CXXMethodDecl *method);
+
+bool CanUseCopyOrMoveName(const clang::CXXMethodDecl *decl,
+                          const std::string &name);
+
 bool IsUserDefinedCopyConstructor(const clang::CXXConstructorDecl *ctor);
 
 bool IsConvertibleCopyOrMoveConstructor(const clang::CXXConstructorDecl *ctor);

docs/src/codegen/types/classes.md

@@ -90,9 +90,9 @@ behind pointers, is emitted at the end of the file as an empty
 
 A constructor becomes an associated function named after the class. It opens
 with `let mut this = Self { ... }`, one field per member initializer, then runs
-the C++ body and returns `this`. Only implicit or defaulted copy and move
-constructors are supported: a user-defined one stops the translation, and the
-implicit copy is what the `Clone` impl represents.
+the C++ body and returns `this`. Copy and move constructors become `copy_from`
+and `move_from` (see [Naming](./naming.md)); the `Clone` impl calls `copy_from`
+when the copy constructor is user-defined.
 
 Methods take `&self` when `const` and `&mut self` otherwise in the unsafe model.
 In the refcount model they always take `&self`, since mutation goes through the

docs/src/codegen/types/naming.md

@@ -27,3 +27,8 @@ name unless they are overloaded, in which case the parameter types are appended
 (`method_i32`, `method_i32_const`). `operator<` is emitted as `lt`; comparison
 operators additionally produce the corresponding trait impls (`PartialOrd`,
 `Ord`, `PartialEq`).
+
+Copy and move constructors are named `copy_from` and `move_from`, and copy and
+move assignment operators `copy_assign` and `move_assign`, as long as the class
+has only one member of that kind and no method already uses the name; otherwise
+they get the overloaded form.

tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs

@@ -24,7 +24,7 @@ impl S {
         let this: Ptr<S> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn S_pmutS_rv(_a0: Ptr<S>) -> Self {
+    pub fn move_from(_a0: Ptr<S>) -> Self {
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new(std::mem::take(
                 &mut (*(*_a0.upgrade().deref()).v.borrow_mut()),
@@ -84,18 +84,18 @@ fn main_0() -> i32 {
 pub fn shuffle_1(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     let a: Value<S> = Rc::new(RefCell::new(S::new({ (*x.borrow()) })));
-    let b: Value<S> = Rc::new(RefCell::new(S::S_pmutS_rv({ a.as_pointer() })));
+    let b: Value<S> = Rc::new(RefCell::new(S::move_from({ a.as_pointer() })));
     assert!((*(*a.borrow()).v.borrow()).is_empty());
     let c: Value<S> = Rc::new(RefCell::new(S::new({ 1 })));
-    ({ SImpl::operator_assign_pmutS_rv(&c.as_pointer(), b.as_pointer()) });
+    ({ SImpl::move_assign(&c.as_pointer(), b.as_pointer()) });
     assert!((*(*b.borrow()).v.borrow()).is_empty());
     return ({ sum_0(c.as_pointer()) });
 }
 pub trait SImpl {
-    fn operator_assign_pmutS_rv(&self, _a0: Ptr<S>) -> Ptr<S>;
+    fn move_assign(&self, _a0: Ptr<S>) -> Ptr<S>;
 }
 impl SImpl for Ptr<S> {
-    fn operator_assign_pmutS_rv(&self, _a0: Ptr<S>) -> Ptr<S> {
+    fn move_assign(&self, _a0: Ptr<S>) -> Ptr<S> {
         ((*(*self).upgrade().deref()).v.as_pointer() as Ptr<Vec<i32>>).write(std::mem::take(
             &mut (*(*_a0.upgrade().deref()).v.borrow_mut()),
         ));

tests/multi-file/defaulted_move_cross_tu/out/unsafe/defaulted_move_cross_tu.rs

@@ -20,14 +20,14 @@ impl S {
         };
         this
     }
-    pub unsafe fn S_pmutS_rv(_a0: *mut S) -> Self {
+    pub unsafe fn move_from(_a0: *mut S) -> Self {
         let mut this = Self {
             v: std::mem::take(&mut (*_a0).v),
             n: std::array::from_fn::<_, 2, _>(|__i: usize| (*_a0).n[(__i)]),
         };
         this
     }
-    pub unsafe fn operator_assign_pmutS_rv(&mut self, _a0: *mut S) -> *mut S {
+    pub unsafe fn move_assign(&mut self, _a0: *mut S) -> *mut S {
         self.v = std::mem::take(&mut (*_a0).v);
         {
             if 8_usize != 0 {
@@ -67,10 +67,10 @@ unsafe fn main_0() -> i32 {
 }
 pub unsafe fn shuffle_1(mut x: i32) -> i32 {
     let mut a: S = S::new({ x });
-    let mut b: S = S::S_pmutS_rv({ &mut a });
+    let mut b: S = S::move_from({ &mut a });
     assert!(a.v.is_empty());
     let mut c: S = S::new({ 1 });
-    (unsafe { S::operator_assign_pmutS_rv(&mut c, &mut b) });
+    (unsafe { S::move_assign(&mut c, &mut b) });
     assert!(b.v.is_empty());
     return (unsafe { sum_0(&c) });
 }

tests/unit/out/refcount/copy_assign.rs

@@ -25,7 +25,7 @@ impl Partial {
         let this: Ptr<Partial> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Partial_pconstPartial(o: Ptr<Partial>) -> Self {
+    pub fn copy_from(o: Ptr<Partial>) -> Self {
         let __this: Value<Partial> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*(*o.upgrade().deref()).v.borrow()))),
             keep: Rc::new(RefCell::new((*(*o.upgrade().deref()).keep.borrow()))),
@@ -40,7 +40,7 @@ impl Clone for Partial {
             v: self.v.clone(),
             keep: self.keep.clone(),
         }));
-        Partial::Partial_pconstPartial(__src.as_pointer())
+        Partial::copy_from(__src.as_pointer())
     }
 }
 impl ByteRepr for Partial {
@@ -146,14 +146,10 @@ pub struct Holder {
 impl Clone for Holder {
     fn clone(&self) -> Self {
         let __this: Value<Holder> = Rc::new(RefCell::new(Self {
-            p: Rc::new(RefCell::new(Partial::Partial_pconstPartial({
-                self.p.as_pointer()
-            }))),
+            p: Rc::new(RefCell::new(Partial::copy_from({ self.p.as_pointer() }))),
             arr: Rc::new(RefCell::new(Box::new(std::array::from_fn::<_, 2, _>(
                 |__i: usize| {
-                    Partial::Partial_pconstPartial({
-                        (self.arr.as_pointer() as Ptr<Partial>).offset(__i)
-                    })
+                    Partial::copy_from({ (self.arr.as_pointer() as Ptr<Partial>).offset(__i) })
                 },
             )))),
         }));
@@ -196,38 +192,38 @@ fn main_0() -> i32 {
     let a: Value<Partial> = Rc::new(RefCell::new(Partial::new({ 1 }, { 100 })));
     let b: Value<Partial> = Rc::new(RefCell::new(Partial::new({ 2 }, { 200 })));
     let c: Value<Partial> = Rc::new(RefCell::new(Partial::new({ 3 }, { 300 })));
-    ({ PartialImpl::operator_assign(&a.as_pointer(), b.as_pointer()) });
+    ({ PartialImpl::copy_assign(&a.as_pointer(), b.as_pointer()) });
     assert!(((*(*a.borrow()).v.borrow()) == 2) && ((*(*a.borrow()).keep.borrow()) == 100));
     assert!((assigns_0.with(|rc| *rc.borrow()) == 1));
     ({
-        PartialImpl::operator_assign(
+        PartialImpl::copy_assign(
             &c.as_pointer(),
-            ({ PartialImpl::operator_assign(&a.as_pointer(), b.as_pointer()) }),
+            ({ PartialImpl::copy_assign(&a.as_pointer(), b.as_pointer()) }),
         )
     });
     assert!(((*(*c.borrow()).v.borrow()) == 2) && ((*(*c.borrow()).keep.borrow()) == 300));
     assert!((assigns_0.with(|rc| *rc.borrow()) == 3));
     ({
         let _o: Ptr<Partial> = a.as_pointer();
-        PartialImpl::operator_assign(&a.as_pointer(), _o)
+        PartialImpl::copy_assign(&a.as_pointer(), _o)
     });
     assert!((assigns_0.with(|rc| *rc.borrow()) == 3));
     ({
         let _o: Value<Partial> = Rc::new(RefCell::new(Partial::new({ 9 }, { 900 })));
-        PartialImpl::operator_assign(&a.as_pointer(), _o.as_pointer())
+        PartialImpl::copy_assign(&a.as_pointer(), _o.as_pointer())
     });
     assert!(((*(*a.borrow()).v.borrow()) == 9) && ((*(*a.borrow()).keep.borrow()) == 100));
     assert!((assigns_0.with(|rc| *rc.borrow()) == 4));
     let ra: Ptr<Partial> = a.as_pointer();
     ({
         let _o: Ptr<Partial> = c.as_pointer();
-        PartialImpl::operator_assign(&ra, _o)
+        PartialImpl::copy_assign(&ra, _o)
     });
     assert!(((*(*a.borrow()).v.borrow()) == 2));
     let pa: Value<Ptr<Partial>> = Rc::new(RefCell::new((a.as_pointer())));
     ({
         let _o: Ptr<Partial> = b.as_pointer();
-        PartialImpl::operator_assign(&(*pa.borrow()), _o)
+        PartialImpl::copy_assign(&(*pa.borrow()), _o)
     });
     assert!(((*(*a.borrow()).v.borrow()) == 2));
     assert!((assigns_0.with(|rc| *rc.borrow()) == 6));
@@ -238,9 +234,9 @@ fn main_0() -> i32 {
             Partial::new({ 6 }, { 60 }),
         ]))),
     }));
-    ({ PartialImpl::operator_assign(&(*h.borrow()).p.as_pointer(), b.as_pointer()) });
+    ({ PartialImpl::copy_assign(&(*h.borrow()).p.as_pointer(), b.as_pointer()) });
     ({
-        PartialImpl::operator_assign(
+        PartialImpl::copy_assign(
             &((*h.borrow()).arr.as_pointer() as Ptr<Partial>).offset(1),
             c.as_pointer(),
         )
@@ -266,7 +262,7 @@ fn main_0() -> i32 {
     assert!(((*(*n2.borrow()).mark.borrow()) == 10));
     let r: Value<RefQualified> = Rc::new(RefCell::new(RefQualified::new()));
     let r1: Value<RefQualified> = Rc::new(RefCell::new(RefQualified::new()));
-    ({ RefQualifiedImpl::operator_assign(&r1.as_pointer(), r.as_pointer()) });
+    ({ RefQualifiedImpl::copy_assign(&r1.as_pointer(), r.as_pointer()) });
     assert!(((*(*r1.borrow()).mark.borrow()) == 1));
     return 0;
 }
@@ -287,10 +283,10 @@ impl NonConstAssignImpl for Ptr<NonConstAssign> {
     }
 }
 pub trait PartialImpl {
-    fn operator_assign(&self, o: Ptr<Partial>) -> Ptr<Partial>;
+    fn copy_assign(&self, o: Ptr<Partial>) -> Ptr<Partial>;
 }
 impl PartialImpl for Ptr<Partial> {
-    fn operator_assign(&self, o: Ptr<Partial>) -> Ptr<Partial> {
+    fn copy_assign(&self, o: Ptr<Partial>) -> Ptr<Partial> {
         if ((*self) == (o)) {
             return (*self).clone();
         }
@@ -301,10 +297,10 @@ impl PartialImpl for Ptr<Partial> {
     }
 }
 pub trait RefQualifiedImpl {
-    fn operator_assign(&self, o: Ptr<RefQualified>) -> Ptr<RefQualified>;
+    fn copy_assign(&self, o: Ptr<RefQualified>) -> Ptr<RefQualified>;
 }
 impl RefQualifiedImpl for Ptr<RefQualified> {
-    fn operator_assign(&self, o: Ptr<RefQualified>) -> Ptr<RefQualified> {
+    fn copy_assign(&self, o: Ptr<RefQualified>) -> Ptr<RefQualified> {
         let __rhs = ((*(*o.upgrade().deref()).mark.borrow()) + 1);
         (*(*(*self).upgrade().deref()).mark.borrow_mut()) = __rhs;
         return (*self).clone();