Translate copy constructor and copy assignment (#342)

Copy constructors are translated in the `impl Self` block, they take no
receiver and build the `Self` object using the provided argument.


If the copy constructor is not defaulted and not deleted, both unsafe
and refcount generate it and Clone calls it.

```rs
impl Counted {
    // Copy constructor
    pub unsafe fn Counted_pconstCounted(o: *const Counted) -> Self {
        let mut this = Self { v: (*o).v };
        copies_0.prefix_inc();
        this
    }
}
impl Clone for Counted {
    // Clone implementation calls the copy constructor
    fn clone(&self) -> Self {
        unsafe { Counted::Counted_pconstCounted(self as *const Counted) }
    }
}
```

If the copy constructor is defaulted, unsafe continues to derive Clone
and refcount continues to generate a deep copy:

```rs
fn clone(&self) -> Self {
  Self {
    field: Rc::new(RefCell::new(field.clone()));
    ...
  }
}
```

Copy assignment is translated using `operator_assign`:

```rs
impl PartialImpl for Ptr<Partial> {
    fn operator_assign(&self, o: Ptr<Partial>) -> Ptr<Partial> {
        if ((*self) == (o)) {
            return (*self).clone();
        }
        ...
        return (*self).clone();
    }
}
```

And users of copy assignment are translated as
`PartialImpl::operator_assign(&a.as_pointer(), b.as_pointer())`

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -624,9 +624,9 @@ void Converter::EmitScopedDestructor(const clang::VarDecl *decl) {
                      kDestructorName));
 }
 
-static bool hasUserDefinedNonDefaultCopyOrMoveCtor(clang::CXXRecordDecl *decl) {
+static bool hasUserDefinedNonDefaultMoveCtor(clang::CXXRecordDecl *decl) {
   for (const auto *ctor : decl->ctors()) {
-    if (ctor->isCopyConstructor() || ctor->isMoveConstructor()) {
+    if (ctor->isMoveConstructor()) {
       auto source = ctor->getDefinition() ? ctor->getDefinition() : ctor;
       if (source->isUserProvided() && !source->isDefaulted()) {
         return true;
@@ -635,8 +635,7 @@ static bool hasUserDefinedNonDefaultCopyOrMoveCtor(clang::CXXRecordDecl *decl) {
   }
 
   for (const auto *method : decl->methods()) {
-    if (method->isCopyAssignmentOperator() ||
-        method->isMoveAssignmentOperator()) {
+    if (method->isMoveAssignmentOperator()) {
       auto source = method->getDefinition() ? method->getDefinition() : method;
       if (source->isUserProvided() && !source->isDefaulted()) {
         return true;
@@ -946,8 +945,8 @@ bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
       return false;
     }
 
-    if (hasUserDefinedNonDefaultCopyOrMoveCtor(decl)) {
-      assert(0 && "unsupported user-defined copy ctor, move ctor");
+    if (hasUserDefinedNonDefaultMoveCtor(decl)) {
+      assert(0 && "unsupported user-defined move ctor");
     }
 
     sema_->ForceDeclarationOfImplicitMembers(decl);
@@ -1048,23 +1047,31 @@ std::string Converter::GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl) {
   return decl->isConst() ? "&self" : "&mut self";
 }
 
+std::string Converter::GetCtorName(clang::CXXConstructorDecl *decl) {
+  if (decl->isCopyConstructor()) {
+    return GetOverloadedFunctionName(decl);
+  }
+  return GetRecordName(decl->getParent()) +
+         (GetNumberOfConvertingCtors(decl->getParent()) != 1
+              ? std::to_string(GetCtorIndex(decl))
+              : "");
+}
+
 bool Converter::VisitCXXConstructorDecl(clang::CXXConstructorDecl *decl) {
   if (decl->isOutOfLine() || decl->isImplicit()) {
     return false;
   }
   PushCurrFunction push_fn(*this, decl);
 
-  if (decl->isCopyOrMoveConstructor()) {
-    // FIXME: improve error handling
-    assert(0 && "user-defined copy or move constructor are not supported");
+  if (decl->isMoveConstructor()) {
+    assert(0 && "user-defined move constructor are not supported");
+  }
+  if (decl->isCopyConstructor() && !decl->doesThisDeclarationHaveABody()) {
+    return false;
   }
 
   ConvertFunctionQualifiers(decl);
-  auto ctor_name = GetRecordName(decl->getParent()) +
-                   (GetNumberOfConvertingCtors(decl->getParent()) != 1
-                        ? std::to_string(GetCtorIndex(decl))
-                        : "");
-  StrCat(keyword_unsafe_, keyword::kFn, ctor_name);
+  StrCat(keyword_unsafe_, keyword::kFn, GetCtorName(decl));
   {
     PushParen paren(*this);
     ConvertFunctionParameters(decl);
@@ -3316,11 +3323,8 @@ void Converter::ConvertArrayCXXConstructExpr(clang::CXXConstructExpr *expr) {
 
 void Converter::ConvertCXXConstructExprArgs(clang::CXXConstructExpr *expr) {
   auto ctor = expr->getConstructor();
-  auto ctor_name = GetRecordName(ctor->getParent());
-  StrCat(ctor_name, token::kDoubleColon,
-         ctor_name + (GetNumberOfConvertingCtors(ctor->getParent()) != 1
-                          ? std::to_string(GetCtorIndex(ctor))
-                          : ""));
+  StrCat(GetRecordName(ctor->getParent()), token::kDoubleColon,
+         GetCtorName(ctor));
   PushParen paren(*this);
 
   unsigned arg_idx = 0;
@@ -3359,9 +3363,7 @@ bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
   }
 
   auto *ctor = expr->getConstructor();
-  if (ctor->isCopyOrMoveConstructor() ||
-      (ctor->isConvertingConstructor(false) && ctor->getNumParams() == 1 &&
-       ctor->getParamDecl(0)->getType()->isRValueReferenceType())) {
+  if (IsPassThroughConstructor(ctor)) {
     // Take suppress before recursing into the child.
     bool suppress = PushSuppressIteratorClone::take(*this);
     Convert(expr->getArg(0));
@@ -3823,15 +3825,12 @@ Converter::GetStructAttributes(const clang::RecordDecl *decl) {
 
   std::vector<const char *> struct_attrs;
 
-  if (RecordHasCopyableFields(decl)) {
+  bool derive_clone =
+      IsCopyConstructible(decl) && !HasUserDefinedCopyConstructor(decl);
+  if (derive_clone && RecordHasCopyableFields(decl)) {
     struct_attrs.emplace_back("Copy");
   }
-
-  if (auto cxx_decl = clang::dyn_cast<clang::CXXRecordDecl>(decl)) {
-    if (!cxx_decl->defaultedCopyConstructorIsDeleted()) {
-      struct_attrs.emplace_back("Clone");
-    }
-  } else /* RecordDecl */ {
+  if (derive_clone) {
     struct_attrs.emplace_back("Clone");
   }
 
@@ -4220,7 +4219,23 @@ void Converter::AddOrdTrait(const clang::CXXRecordDecl *decl) {
   ConvertOrdAndPartialOrdTraits(decl, eq, lt, cmp);
 }
 
-void Converter::AddCloneTrait(const clang::RecordDecl *decl) {}
+void Converter::AddCloneTrait(const clang::RecordDecl *decl) {
+  auto *ctor = GetUserDefinedCopyConstructor(decl);
+  if (!ctor) {
+    return;
+  }
+  auto record_name = GetRecordName(decl);
+  StrCat(keyword::kImpl, "Clone for", record_name);
+  PushBrace impl_brace(*this);
+  StrCat("fn clone(&self) -> Self");
+  PushBrace fn_brace(*this);
+  auto source = ctor->getParamDecl(0)->getType().getNonReferenceType();
+  StrCat(std::format("unsafe {{ {}::{}(self as *const {}{}) }}", record_name,
+                     GetCtorName(ctor), record_name,
+                     source.isConstQualified()
+                         ? ""
+                         : std::format(" as *mut {}", record_name)));
+}
 
 void Converter::AddDefaultTraitForUnion(const clang::RecordDecl *decl) {
   StrCat(std::format("impl Default for {}", GetRecordName(decl)));

cpp2rust/converter/converter.h

@@ -132,6 +132,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   bool ConvertCXXMethodDecl(clang::CXXMethodDecl *decl);
   std::string GetMethodName(const clang::CXXMethodDecl *decl);
   virtual std::string GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl);
+  std::string GetCtorName(clang::CXXConstructorDecl *decl);
   virtual void ConvertCXXRecordMethods(clang::CXXRecordDecl *decl);
   virtual void ConvertLateInstantiatedMethods(clang::CXXRecordDecl *decl);
   virtual std::string DestroyMembers(const clang::CXXRecordDecl *decl);

cpp2rust/converter/converter_lib.cpp

@@ -258,6 +258,57 @@ bool IsOverloadedMethod(const clang::CXXMethodDecl *decl) {
                        }) > 1;
 }
 
+bool IsUserDefinedCopyConstructor(const clang::CXXConstructorDecl *ctor) {
+  return ctor->isCopyConstructor() && ctor->isUserProvided() &&
+         IsUserDefinedDecl(ctor);
+}
+
+clang::CXXConstructorDecl *
+GetUserDefinedCopyConstructor(const clang::RecordDecl *decl) {
+  auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
+  if (!cxx) {
+    return nullptr;
+  }
+  for (auto *ctor : cxx->ctors()) {
+    if (IsUserDefinedCopyConstructor(ctor) && ctor->getDefinition()) {
+      return ctor;
+    }
+  }
+  return nullptr;
+}
+
+bool HasUserDefinedCopyConstructor(const clang::RecordDecl *decl) {
+  return GetUserDefinedCopyConstructor(decl) != nullptr;
+}
+
+bool IsCopyConstructible(const clang::RecordDecl *decl) {
+  auto *cxx = clang::dyn_cast<clang::CXXRecordDecl>(decl);
+  if (!cxx) {
+    return true;
+  }
+  if (!cxx->hasUserDeclaredCopyConstructor()) {
+    return !cxx->defaultedCopyConstructorIsDeleted();
+  }
+  for (const auto *ctor : cxx->ctors()) {
+    if (ctor->isCopyConstructor() && !ctor->isDeleted() &&
+        ctor->getDefinition()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool IsRValueConvertingConstructor(const clang::CXXConstructorDecl *ctor) {
+  return ctor->isConvertingConstructor(false) && ctor->getNumParams() == 1 &&
+         ctor->getParamDecl(0)->getType()->isRValueReferenceType();
+}
+
+bool IsPassThroughConstructor(const clang::CXXConstructorDecl *ctor) {
+  return !IsUserDefinedCopyConstructor(ctor) &&
+         (ctor->isCopyOrMoveConstructor() ||
+          IsRValueConvertingConstructor(ctor));
+}
+
 bool IsConvertibleCXXRecordDecl(const clang::CXXRecordDecl *decl) {
   return decl->isThisDeclarationADefinition() &&
          std::all_of(
@@ -746,6 +797,9 @@ bool RecordNeedsDestruction(const clang::CXXRecordDecl *decl) {
 }
 
 bool IsEmittableMethod(clang::CXXMethodDecl *method) {
+  if (method->isDeleted()) {
+    return false;
+  }
   if (clang::isa<clang::CXXDestructorDecl>(method)) {
     return GetUserDefinedDestructor(method->getParent()) &&
            method->isThisDeclarationADefinition();
@@ -767,8 +821,8 @@ bool IsEmittableMethod(clang::CXXMethodDecl *method) {
 }
 
 bool IsMethodOnPtr(const clang::CXXMethodDecl *method) {
-  if (method->isImplicit() || method->isStatic() || method->isVirtual() ||
-      clang::isa<clang::CXXConstructorDecl>(method)) {
+  if (method->isImplicit() || method->isDeleted() || method->isStatic() ||
+      method->isVirtual() || clang::isa<clang::CXXConstructorDecl>(method)) {
     return false;
   }
   if (!IsUserDefinedDecl(method->getParent()) ||

cpp2rust/converter/converter_lib.h

@@ -63,6 +63,19 @@ bool IsOverloadedFunction(const clang::FunctionDecl *decl);
 
 bool IsOverloadedMethod(const clang::CXXMethodDecl *decl);
 
+bool IsUserDefinedCopyConstructor(const clang::CXXConstructorDecl *ctor);
+
+clang::CXXConstructorDecl *
+GetUserDefinedCopyConstructor(const clang::RecordDecl *decl);
+
+bool HasUserDefinedCopyConstructor(const clang::RecordDecl *decl);
+
+bool IsCopyConstructible(const clang::RecordDecl *decl);
+
+bool IsRValueConvertingConstructor(const clang::CXXConstructorDecl *ctor);
+
+bool IsPassThroughConstructor(const clang::CXXConstructorDecl *ctor);
+
 bool IsConvertibleCXXRecordDecl(const clang::CXXRecordDecl *decl);
 
 bool IsConvertibleCXXMethodDecl(const clang::CXXMethodDecl *decl);

cpp2rust/converter/models/converter_refcount.cpp

@@ -449,6 +449,19 @@ std::string ConverterRefCount::GetComparisonCall(
                      lhs_ptr, rhs_ptr);
 }
 
+void ConverterRefCount::EmitShallowCopy(const clang::RecordDecl *decl) {
+  StrCat("Rc::new");
+  PushParen rc_paren(*this);
+  StrCat("RefCell::new");
+  PushParen cell_paren(*this);
+  StrCat(GetRecordName(decl));
+  PushBrace init_brace(*this);
+  for (auto *field : decl->fields()) {
+    auto name = GetNamedDeclAsString(field);
+    StrCat(std::format("{0}: self.{0}.clone(),", name));
+  }
+}
+
 void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
   auto record_name = GetRecordName(decl);
 
@@ -478,18 +491,26 @@ void ConverterRefCount::AddCloneTrait(const clang::RecordDecl *decl) {
     return;
   }
 
-  if (cxx->defaultedCopyConstructorIsDeleted()) {
+  if (!IsCopyConstructible(cxx)) {
     return;
   }
 
   StrCat(keyword::kImpl, "Clone for", record_name, '{');
   StrCat("fn clone(&self) -> Self {");
 
-  for (auto ctor : cxx->ctors()) {
-    if (ctor->isCopyConstructor()) {
-      PushConversionKind push(*this, ConversionKind::FullRefCount);
-      ConvertCXXConstructorBody(ctor);
-      break;
+  if (auto *ctor = GetUserDefinedCopyConstructor(cxx)) {
+    StrCat(std::format("let __src: Value<{}> =", record_name));
+    EmitShallowCopy(decl);
+    StrCat(token::kSemiColon);
+    StrCat(std::format("{}::{}(__src.as_pointer())", record_name,
+                       GetCtorName(ctor)));
+  } else {
+    for (auto ctor : cxx->ctors()) {
+      if (ctor->isCopyConstructor()) {
+        PushConversionKind push(*this, ConversionKind::FullRefCount);
+        ConvertCXXConstructorBody(ctor);
+        break;
+      }
     }
   }
 
@@ -1845,14 +1866,12 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
   }
 
   auto *ctor = expr->getConstructor();
-  if (ctor->isMoveConstructor() ||
-      (ctor->isConvertingConstructor(false) && ctor->getNumParams() == 1 &&
-       ctor->getParamDecl(0)->getType()->isRValueReferenceType())) {
+  if (ctor->isMoveConstructor() || IsRValueConvertingConstructor(ctor)) {
     StrCat(ConvertLValue(expr->getArg(0)));
     return false;
   }
 
-  if (ctor->isCopyConstructor()) {
+  if (ctor->isCopyConstructor() && !IsUserDefinedCopyConstructor(ctor)) {
     StrCat(PushSuppressIteratorClone::take(*this)
                ? ConvertRValue(expr->getArg(0))
                : ConvertFreshRValue(expr->getArg(0)));

cpp2rust/converter/models/converter_refcount.h

@@ -41,6 +41,7 @@ class ConverterRefCount final : public Converter {
                                 std::string_view lhs,
                                 std::string_view rhs) override;
 
+  void EmitShallowCopy(const clang::RecordDecl *decl);
   void AddCloneTrait(const clang::RecordDecl *decl) override;
 
   void AddByteReprTrait(const clang::RecordDecl *decl) override;