Merge branch 'master' into remove-emplace-back-plugin

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -686,6 +686,10 @@ bool Converter::RecordDerivesDefault(const clang::RecordDecl *decl) {
   }
 
   for (auto f : decl->fields()) {
+    if (f->hasInClassInitializer()) {
+      return false;
+    }
+
     // Records that contain function pointer do not derive Default
     if (auto ptr_ty = f->getType()->getAs<clang::PointerType>()) {
       if (ptr_ty->getPointeeType()->isFunctionType()) {
@@ -1096,6 +1100,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);
   }
@@ -1145,6 +1153,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
@@ -3328,7 +3340,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()) {
@@ -3370,6 +3382,7 @@ bool Converter::VisitArrayInitLoopExpr(clang::ArrayInitLoopExpr *expr) {
 }
 
 bool Converter::VisitInitListExpr(clang::InitListExpr *expr) {
+  auto *syntactic = expr->isSyntacticForm() ? expr : expr->getSyntacticForm();
   if (auto form = expr->getSemanticForm())
     expr = form;
 
@@ -3395,6 +3408,12 @@ bool Converter::VisitInitListExpr(clang::InitListExpr *expr) {
       return false;
     }
 
+    if (syntactic->getNumInits() == 0) {
+      StrCat(GetDefaultAsString(qual_type));
+      SetFreshType(qual_type);
+      return false;
+    }
+
     StrCat(GetUnsafeTypeAsString(qual_type));
     PushBrace brace(*this);
     int i = 0;
@@ -4038,18 +4057,6 @@ std::string Converter::GetDefaultAsStringFallback(clang::QualType qual_type) {
     return getTypedLiteral("0.0", ToString(qual_type));
   }
 
-  if (auto record = qual_type->getAsRecordDecl();
-      record && in_const_initializer_) {
-    if (auto cxx = clang::dyn_cast<clang::CXXRecordDecl>(record)) {
-      ENSURE(GetUserDefinedDefaultConstructor(cxx) == nullptr &&
-             "Default initializing globals using default constructor is not "
-             "supported");
-    }
-    Buffer buf(*this);
-    EmitDefaultStructLiteral(record);
-    return std::move(buf).str();
-  }
-
   if (auto record = qual_type->getAsRecordDecl()) {
     if (ctx_.getSourceManager().isInSystemHeader(record->getLocation()) &&
         qual_type.isPODType(ctx_)) {
@@ -4708,8 +4715,13 @@ void Converter::EmitDefaultStructLiteral(const clang::RecordDecl *decl) {
   StrCat(GetRecordName(decl));
   PushBrace brace(*this);
   for (auto *field : decl->fields()) {
-    StrCat(GetNamedDeclAsString(field), token::kColon,
-           GetDefaultAsString(field->getType()), token::kComma);
+    StrCat(GetNamedDeclAsString(field), token::kColon);
+    if (auto *init = field->getInClassInitializer()) {
+      ConvertVarInit(field->getType(), init);
+    } else {
+      StrCat(GetDefaultAsString(field->getType()));
+    }
+    StrCat(token::kComma);
   }
 }
 

cpp2rust/converter/converter_lib.cpp

@@ -288,6 +288,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

@@ -74,6 +74,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);

cpp2rust/converter/models/converter_refcount.cpp

@@ -1595,6 +1595,7 @@ void ConverterRefCount::ConvertBinaryOperator(clang::BinaryOperator *expr) {
 }
 
 bool ConverterRefCount::VisitInitListExpr(clang::InitListExpr *expr) {
+  auto *syntactic = expr->isSyntacticForm() ? expr : expr->getSyntacticForm();
   if (auto form = expr->getSemanticForm())
     expr = form;
 
@@ -1620,6 +1621,15 @@ bool ConverterRefCount::VisitInitListExpr(clang::InitListExpr *expr) {
       return false;
     }
 
+    if (syntactic->getNumInits() == 0) {
+      {
+        PushConversionKind push(*this, ConversionKind::Unboxed);
+        StrCat(GetDefaultAsString(qual_type));
+      }
+      computed_expr_type_ = ComputedExprType::FreshValue;
+      return false;
+    }
+
     StrCat(GetUnsafeTypeAsString(qual_type));
     {
       PushBrace brace(*this);
@@ -2111,6 +2121,18 @@ std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) {
 
 std::string
 ConverterRefCount::GetDefaultAsStringFallback(clang::QualType qual_type) {
+  auto canonical = qual_type.getUnqualifiedType().getCanonicalType();
+  if (canonical->isBooleanType() ||
+      (canonical->isIntegerType() && !canonical->isEnumeralType()) ||
+      canonical->isFloatingType()) {
+    std::string unboxed;
+    {
+      PushConversionKind push(*this, ConversionKind::Unboxed);
+      unboxed = Converter::GetDefaultAsStringFallback(qual_type);
+    }
+    return BoxValue(std::move(unboxed));
+  }
+
   return std::format("<{}>::default()", ToString(qual_type));
 }
 

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()),
@@ -41,9 +41,7 @@ impl Default for S {
     fn default() -> Self {
         S {
             v: Rc::new(RefCell::new(Default::default())),
-            n: Rc::new(RefCell::new(
-                (0..2).map(|_| <i32>::default()).collect::<Box<[i32]>>(),
-            )),
+            n: Rc::new(RefCell::new((0..2).map(|_| 0_i32).collect::<Box<[i32]>>())),
         }
     }
 }
@@ -84,18 +82,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/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs

@@ -6,7 +6,7 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-#[derive(Default)]
+#[derive()]
 pub struct S_int_ {
     pub x: Value<i32>,
 }
@@ -19,6 +19,13 @@ impl Clone for S_int_ {
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
 }
+impl Default for S_int_ {
+    fn default() -> Self {
+        S_int_ {
+            x: Rc::new(RefCell::new(0)),
+        }
+    }
+}
 impl ByteRepr for S_int_ {
     fn byte_size() -> usize {
         4

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

@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 #[repr(C)]
-#[derive(Copy, Clone, Default)]
+#[derive(Copy, Clone)]
 pub struct S_int_ {
     pub x: i32,
 }
@@ -16,6 +16,11 @@ impl S_int_ {
         self.x = v;
     }
 }
+impl Default for S_int_ {
+    fn default() -> Self {
+        S_int_ { x: 0 }
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();