Translate nameless copy constructor agrument as _a0 instead of self

Author: lucic71

cpp2rust/converter/converter_lib.cpp

@@ -732,7 +732,7 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
         llvm::dyn_cast<clang::FunctionDecl>(pdecl->getDeclContext());
     const auto *ctor = llvm::dyn_cast_or_null<clang::CXXConstructorDecl>(fn);
     if (pdecl->isExplicitObjectParameter() ||
-        (ctor && ctor->isCopyConstructor())) {
+        (ctor && ctor->isCopyConstructor() && ctor->isDefaulted())) {
       name = "self";
     } else {
       name = std::format("_a{}", pdecl->getFunctionScopeIndex());

tests/unit/copy_ctor.cpp

@@ -17,6 +17,12 @@ struct NonConst {
   NonConst(const NonConst &o) : mark(o.mark + 10) {}
 };
 
+struct Ignored {
+  int v;
+  Ignored(int v) : v(v) {}
+  Ignored(const Ignored &) : v(-1) { ++copies; }
+};
+
 struct Holder {
   Counted c;
   Counted arr[2];
@@ -63,6 +69,11 @@ int main() {
   assert(vec[0].v == 1);
   assert(copies == 10);
 
+  Ignored i1(1);
+  Ignored i2(i1);
+  assert(i1.v == 1 && i2.v == -1);
+  assert(copies == 11);
+
   NonConst n;
   NonConst n1(n);
   const NonConst cn;

tests/unit/out/refcount/copy_ctor.rs

@@ -103,6 +103,47 @@ impl ByteRepr for NonConst {
         }
     }
 }
+#[derive(Default)]
+pub struct Ignored {
+    pub v: Value<i32>,
+}
+impl Ignored {
+    pub fn Ignored(v: i32) -> Self {
+        let v: Value<i32> = Rc::new(RefCell::new(v));
+        let __this: Value<Ignored> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*v.borrow()))),
+        }));
+        let this: Ptr<Ignored> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+    pub fn Ignored_pconstIgnored(_a0: Ptr<Ignored>) -> Self {
+        let __this: Value<Ignored> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new(-1_i32)),
+        }));
+        let this: Ptr<Ignored> = __this.as_pointer();
+        (*copies_0.with(Value::clone).borrow_mut()).prefix_inc();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Clone for Ignored {
+    fn clone(&self) -> Self {
+        let __src: Value<Ignored> = Rc::new(RefCell::new(Ignored { v: self.v.clone() }));
+        Ignored::Ignored_pconstIgnored(__src.as_pointer())
+    }
+}
+impl ByteRepr for Ignored {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
 #[derive()]
 pub struct Holder {
     pub c: Value<Counted>,
@@ -225,6 +266,12 @@ fn main_0() -> i32 {
             == 1)
     );
     assert!((copies_0.with(|rc| *rc.borrow()) == 10));
+    let i1: Value<Ignored> = Rc::new(RefCell::new(Ignored::Ignored({ 1 })));
+    let i2: Value<Ignored> = Rc::new(RefCell::new(Ignored::Ignored_pconstIgnored({
+        i1.as_pointer()
+    })));
+    assert!(((*(*i1.borrow()).v.borrow()) == 1) && ((*(*i2.borrow()).v.borrow()) == -1_i32));
+    assert!((copies_0.with(|rc| *rc.borrow()) == 11));
     let n: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst()));
     let n1: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_pmutNonConst({
         n.as_pointer()

tests/unit/out/unsafe/copy_ctor.rs

@@ -62,6 +62,27 @@ impl Default for NonConst {
     }
 }
 #[repr(C)]
+#[derive(Default)]
+pub struct Ignored {
+    pub v: i32,
+}
+impl Ignored {
+    pub unsafe fn Ignored(mut v: i32) -> Self {
+        let mut this = Self { v: v };
+        this
+    }
+    pub unsafe fn Ignored_pconstIgnored(_a0: *const Ignored) -> Self {
+        let mut this = Self { v: -1_i32 };
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)).prefix_inc();
+        this
+    }
+}
+impl Clone for Ignored {
+    fn clone(&self) -> Self {
+        unsafe { Ignored::Ignored_pconstIgnored(self as *const Ignored) }
+    }
+}
+#[repr(C)]
 #[derive(Clone)]
 pub struct Holder {
     pub c: Counted,
@@ -124,6 +145,10 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((vec_[(0_usize)].v) == (1)));
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (10)));
+    let mut i1: Ignored = Ignored::Ignored({ 1 });
+    let mut i2: Ignored = Ignored::Ignored_pconstIgnored({ &i1 });
+    assert!(((i1.v) == (1)) && ((i2.v) == (-1_i32)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (11)));
     let mut n: NonConst = NonConst::NonConst();
     let mut n1: NonConst = NonConst::NonConst_pmutNonConst({ &mut n });
     let cn: NonConst = NonConst::NonConst();