Use idiomatic S::new for ctor instead of S::S (#420)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1146,10 +1146,9 @@ std::string Converter::GetCtorName(clang::CXXConstructorDecl *decl) {
   if (decl->isCopyOrMoveConstructor()) {
     return GetOverloadedFunctionName(decl);
   }
-  return GetRecordName(decl->getParent()) +
-         (GetNumberOfConvertingCtors(decl->getParent()) != 1
-              ? std::to_string(GetCtorIndex(decl))
-              : "");
+  return GetNumberOfConvertingCtors(decl->getParent()) != 1
+             ? std::format("new_{}", GetCtorIndex(decl))
+             : "new";
 }
 
 bool Converter::VisitCXXConstructorDecl(clang::CXXConstructorDecl *decl) {

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

@@ -12,7 +12,7 @@ pub struct S {
     pub n: Value<Box<[i32]>>,
 }
 impl S {
-    pub fn S(x: i32) -> Self {
+    pub fn new(x: i32) -> Self {
         let x: Value<i32> = Rc::new(RefCell::new(x));
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new(vec![
@@ -76,17 +76,17 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let s: Value<S> = Rc::new(RefCell::new(S::S({ 2 })));
+    let s: Value<S> = Rc::new(RefCell::new(S::new({ 2 })));
     assert!((({ sum_0(s.as_pointer(),) }) == 7));
     assert!((({ shuffle_1(3,) }) == 10));
     return 0;
 }
 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::S({ (*x.borrow()) })));
+    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() })));
     assert!((*(*a.borrow()).v.borrow()).is_empty());
-    let c: Value<S> = Rc::new(RefCell::new(S::S({ 1 })));
+    let c: Value<S> = Rc::new(RefCell::new(S::new({ 1 })));
     ({ SImpl::operator_assign_pmutS_rv(&c.as_pointer(), b.as_pointer()) });
     assert!((*(*b.borrow()).v.borrow()).is_empty());
     return ({ sum_0(c.as_pointer()) });

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

@@ -13,7 +13,7 @@ pub struct S {
     pub n: [i32; 2],
 }
 impl S {
-    pub unsafe fn S(mut x: i32) -> Self {
+    pub unsafe fn new(mut x: i32) -> Self {
         let mut this = Self {
             v: vec![x; (x as usize) as usize],
             n: [x, ((x) + (1))],
@@ -60,16 +60,16 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: S = S::S({ 2 });
+    let mut s: S = S::new({ 2 });
     assert!(((unsafe { sum_0(&s,) }) == (7)));
     assert!(((unsafe { shuffle_1(3,) }) == (10)));
     return 0;
 }
 pub unsafe fn shuffle_1(mut x: i32) -> i32 {
-    let mut a: S = S::S({ x });
+    let mut a: S = S::new({ x });
     let mut b: S = S::S_pmutS_rv({ &mut a });
     assert!(a.v.is_empty());
-    let mut c: S = S::S({ 1 });
+    let mut c: S = S::new({ 1 });
     (unsafe { S::operator_assign_pmutS_rv(&mut c, &mut b) });
     assert!(b.v.is_empty());
     return (unsafe { sum_0(&c) });

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

@@ -68,20 +68,20 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let s: Value<S> = Rc::new(RefCell::new(S::S({ 1 })));
+    let s: Value<S> = Rc::new(RefCell::new(S::new({ 1 })));
     assert!((({ SImpl::get(&s.as_pointer(),) }) == 1));
     ({ SImpl::set(&s.as_pointer(), 4) });
     assert!((({ SImpl::get(&s.as_pointer(),) }) == 4));
     assert!((({ SImpl::add(&s.as_pointer(), 2,) }) == 6));
-    let derived: Value<Derived> = Rc::new(RefCell::new(Derived::Derived({ 3 })));
+    let derived: Value<Derived> = Rc::new(RefCell::new(Derived::new({ 3 })));
     let base: Value<PtrDyn<dyn Base>> = Rc::new(RefCell::new(
         (derived.as_pointer()).to_dyn::<dyn Base>(|w| w),
     ));
     assert!((({ (*(*base.borrow()).upgrade().deref()).apply(5,) }) == 15));
     return 0;
 }
 impl S {
-    pub fn S(x: i32) -> Self {
+    pub fn new(x: i32) -> Self {
         let x: Value<i32> = Rc::new(RefCell::new(x));
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*x.borrow()))),
@@ -91,7 +91,7 @@ impl S {
     }
 }
 impl Derived {
-    pub fn Derived(factor: i32) -> Self {
+    pub fn new(factor: i32) -> Self {
         let factor: Value<i32> = Rc::new(RefCell::new(factor));
         let __this: Value<Derived> = Rc::new(RefCell::new(Self {
             factor: Rc::new(RefCell::new((*factor.borrow()))),

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

@@ -32,24 +32,24 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: S = S::S({ 1 });
+    let mut s: S = S::new({ 1 });
     assert!(((unsafe { S::get(&s,) }) == (1)));
     (unsafe { S::set(&mut s, 4) });
     assert!(((unsafe { S::get(&s,) }) == (4)));
     assert!(((unsafe { S::add(&mut s, 2,) }) == (6)));
-    let mut derived: Derived = Derived::Derived({ 3 });
+    let mut derived: Derived = Derived::new({ 3 });
     let mut base: *mut dyn Base = (&mut derived as *mut Derived);
     assert!(((unsafe { (*base).apply(5,) }) == (15)));
     return 0;
 }
 impl S {
-    pub unsafe fn S(mut x: i32) -> Self {
+    pub unsafe fn new(mut x: i32) -> Self {
         let mut this = Self { v: x };
         this
     }
 }
 impl Derived {
-    pub unsafe fn Derived(mut factor: i32) -> Self {
+    pub unsafe fn new(mut factor: i32) -> Self {
         let mut this = Self { factor: factor };
         this
     }

tests/ub/out/refcount/ctor_ref_member.rs

@@ -11,7 +11,7 @@ pub struct S {
     pub r: Ptr<i32>,
 }
 impl S {
-    pub fn S(x: Ptr<i32>) -> Self {
+    pub fn new(x: Ptr<i32>) -> Self {
         let __this: Value<S> = Rc::new(RefCell::new(Self { r: (x).clone() }));
         let this: Ptr<S> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
@@ -23,7 +23,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let s: Value<S> = Rc::new(RefCell::new(S::S({
+    let s: Value<S> = Rc::new(RefCell::new(S::new({
         let __tmp_0: Value<i32> = Rc::new(RefCell::new(5));
         __tmp_0.as_pointer()
     })));

tests/ub/out/unsafe/ctor_ref_member.rs

@@ -12,7 +12,7 @@ pub struct S {
     pub r: *const i32,
 }
 impl S {
-    pub unsafe fn S(x: *const i32) -> Self {
+    pub unsafe fn new(x: *const i32) -> Self {
         let mut this = Self { r: x };
         this
     }
@@ -24,7 +24,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: S = S::S({
+    let mut s: S = S::new({
         let mut __tmp_0: i32 = 5;
         &mut __tmp_0
     });

tests/unit/out/refcount/10_struct.rs

@@ -71,7 +71,7 @@ pub struct Partial {
     pub p: Value<Ptr<i32>>,
 }
 impl Partial {
-    pub fn Partial1(q: Ptr<i32>) -> Self {
+    pub fn new_1(q: Ptr<i32>) -> Self {
         let q: Value<Ptr<i32>> = Rc::new(RefCell::new(q));
         let __this: Value<Partial> = Rc::new(RefCell::new(Self {
             p: Rc::new(RefCell::new((*q.borrow()).clone())),
@@ -145,7 +145,7 @@ fn main_0() -> i32 {
         adj: Rc::new(RefCell::new(Ptr::<Ptr<GraphNode>>::null())),
     }));
     let arr: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([3, 1, 4])));
-    let it: Value<Partial> = Rc::new(RefCell::new(Partial::Partial1({
+    let it: Value<Partial> = Rc::new(RefCell::new(Partial::new_1({
         (arr.as_pointer() as Ptr<i32>)
     })));
     if {

tests/unit/out/refcount/constructor.rs

@@ -14,7 +14,7 @@ pub struct S {
     pub v: Value<i32>,
 }
 impl S {
-    pub fn S(init: i32) -> Self {
+    pub fn new(init: i32) -> Self {
         let init: Value<i32> = Rc::new(RefCell::new(init));
         let __this: Value<S> = Rc::new(RefCell::new(Self {
             v: Rc::new(RefCell::new((*init.borrow()))),
@@ -53,7 +53,7 @@ pub struct Point {
     pub y: Value<i32>,
 }
 impl Point {
-    pub fn Point1(x: i32, y: i32) -> Self {
+    pub fn new_1(x: i32, y: i32) -> Self {
         let x: Value<i32> = Rc::new(RefCell::new(x));
         let y: Value<i32> = Rc::new(RefCell::new(y));
         let __this: Value<Point> = Rc::new(RefCell::new(Self {
@@ -63,17 +63,17 @@ impl Point {
         let this: Ptr<Point> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Point2(v: i32) -> Self {
+    pub fn new_2(v: i32) -> Self {
         let v: Value<i32> = Rc::new(RefCell::new(v));
-        let __this: Value<Point> = Rc::new(RefCell::new(Point::Point1({ (*v.borrow()) }, {
+        let __this: Value<Point> = Rc::new(RefCell::new(Point::new_1({ (*v.borrow()) }, {
             ((*v.borrow()) + 1)
         })));
         let this: Ptr<Point> = __this.as_pointer();
         (*(*this.upgrade().deref()).y.borrow_mut()) *= 10;
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn Point3() -> Self {
-        let __this: Value<Point> = Rc::new(RefCell::new(Point::Point2({ 4 })));
+    pub fn new_3() -> Self {
+        let __this: Value<Point> = Rc::new(RefCell::new(Point::new_2({ 4 })));
         let this: Ptr<Point> = __this.as_pointer();
         (*(*this.upgrade().deref()).x.borrow_mut()) += 100;
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
@@ -91,7 +91,7 @@ impl Clone for Point {
 }
 impl Default for Point {
     fn default() -> Self {
-        { Point::Point3() }
+        { Point::new_3() }
     }
 }
 impl ByteRepr for Point {
@@ -115,16 +115,16 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     {
-        let s: Value<S> = Rc::new(RefCell::new(S::S({ 3 })));
+        let s: Value<S> = Rc::new(RefCell::new(S::new({ 3 })));
         let _dtor_s = ScopedDestructor::new(&s, |__p| __p.destructor());
         assert!(((*(*s.borrow()).v.borrow()) == 4));
         assert!((total_0.with(|rc| *rc.borrow()) == 8));
     }
     assert!((total_0.with(|rc| *rc.borrow()) == 18));
-    let p: Value<Point> = Rc::new(RefCell::new(Point::Point3()));
+    let p: Value<Point> = Rc::new(RefCell::new(Point::new_3()));
     assert!(((*(*p.borrow()).x.borrow()) == 104));
     assert!(((*(*p.borrow()).y.borrow()) == 50));
-    let q: Value<Point> = Rc::new(RefCell::new(Point::Point2({ 7 })));
+    let q: Value<Point> = Rc::new(RefCell::new(Point::new_2({ 7 })));
     assert!(((*(*q.borrow()).x.borrow()) == 7));
     assert!(((*(*q.borrow()).y.borrow()) == 80));
     return 0;

tests/unit/out/refcount/copy_assign.rs

@@ -15,7 +15,7 @@ pub struct Partial {
     pub keep: Value<i32>,
 }
 impl Partial {
-    pub fn Partial(v: i32, keep: i32) -> Self {
+    pub fn new(v: i32, keep: i32) -> Self {
         let v: Value<i32> = Rc::new(RefCell::new(v));
         let keep: Value<i32> = Rc::new(RefCell::new(keep));
         let __this: Value<Partial> = Rc::new(RefCell::new(Self {
@@ -63,7 +63,7 @@ pub struct NonConstAssign {
     pub mark: Value<i32>,
 }
 impl NonConstAssign {
-    pub fn NonConstAssign() -> Self {
+    pub fn new() -> Self {
         let __this: Value<NonConstAssign> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(0)),
         }));
@@ -82,7 +82,7 @@ impl Clone for NonConstAssign {
 }
 impl Default for NonConstAssign {
     fn default() -> Self {
-        { NonConstAssign::NonConstAssign() }
+        { NonConstAssign::new() }
     }
 }
 impl ByteRepr for NonConstAssign {
@@ -103,7 +103,7 @@ pub struct RefQualified {
     pub mark: Value<i32>,
 }
 impl RefQualified {
-    pub fn RefQualified() -> Self {
+    pub fn new() -> Self {
         let __this: Value<RefQualified> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(0)),
         }));
@@ -122,7 +122,7 @@ impl Clone for RefQualified {
 }
 impl Default for RefQualified {
     fn default() -> Self {
-        { RefQualified::RefQualified() }
+        { RefQualified::new() }
     }
 }
 impl ByteRepr for RefQualified {
@@ -193,9 +193,9 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let a: Value<Partial> = Rc::new(RefCell::new(Partial::Partial({ 1 }, { 100 })));
-    let b: Value<Partial> = Rc::new(RefCell::new(Partial::Partial({ 2 }, { 200 })));
-    let c: Value<Partial> = Rc::new(RefCell::new(Partial::Partial({ 3 }, { 300 })));
+    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()) });
     assert!(((*(*a.borrow()).v.borrow()) == 2) && ((*(*a.borrow()).keep.borrow()) == 100));
     assert!((assigns_0.with(|rc| *rc.borrow()) == 1));
@@ -213,7 +213,7 @@ fn main_0() -> i32 {
     });
     assert!((assigns_0.with(|rc| *rc.borrow()) == 3));
     ({
-        let _o: Value<Partial> = Rc::new(RefCell::new(Partial::Partial({ 9 }, { 900 })));
+        let _o: Value<Partial> = Rc::new(RefCell::new(Partial::new({ 9 }, { 900 })));
         PartialImpl::operator_assign(&a.as_pointer(), _o.as_pointer())
     });
     assert!(((*(*a.borrow()).v.borrow()) == 9) && ((*(*a.borrow()).keep.borrow()) == 100));
@@ -232,10 +232,10 @@ fn main_0() -> i32 {
     assert!(((*(*a.borrow()).v.borrow()) == 2));
     assert!((assigns_0.with(|rc| *rc.borrow()) == 6));
     let h: Value<Holder> = Rc::new(RefCell::new(Holder {
-        p: Rc::new(RefCell::new(Partial::Partial({ 4 }, { 40 }))),
+        p: Rc::new(RefCell::new(Partial::new({ 4 }, { 40 }))),
         arr: Rc::new(RefCell::new(Box::new([
-            Partial::Partial({ 5 }, { 50 }),
-            Partial::Partial({ 6 }, { 60 }),
+            Partial::new({ 5 }, { 50 }),
+            Partial::new({ 6 }, { 60 }),
         ]))),
     }));
     ({ PartialImpl::operator_assign(&(*h.borrow()).p.as_pointer(), b.as_pointer()) });
@@ -254,18 +254,18 @@ fn main_0() -> i32 {
             && ((*(*(*h.borrow()).arr.borrow())[(1) as usize].keep.borrow()) == 60)
     );
     assert!((assigns_0.with(|rc| *rc.borrow()) == 8));
-    let n: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::NonConstAssign()));
-    let n1: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::NonConstAssign()));
-    let n2: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::NonConstAssign()));
-    let cn: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::NonConstAssign()));
+    let n: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
+    let n1: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
+    let n2: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
+    let cn: Value<NonConstAssign> = Rc::new(RefCell::new(NonConstAssign::new()));
     ({ NonConstAssignImpl::operator_assign_pmutNonConstAssign(&n1.as_pointer(), n.as_pointer()) });
     ({
         NonConstAssignImpl::operator_assign_pconstNonConstAssign(&n2.as_pointer(), cn.as_pointer())
     });
     assert!(((*(*n1.borrow()).mark.borrow()) == 1));
     assert!(((*(*n2.borrow()).mark.borrow()) == 10));
-    let r: Value<RefQualified> = Rc::new(RefCell::new(RefQualified::RefQualified()));
-    let r1: Value<RefQualified> = Rc::new(RefCell::new(RefQualified::RefQualified()));
+    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()) });
     assert!(((*(*r1.borrow()).mark.borrow()) == 1));
     return 0;