Avoid extremely long names in overloaded methods

cpp2rust/converter/converter.cpp

@@ -1108,7 +1108,7 @@ std::string Converter::GetCtorName(clang::CXXConstructorDecl *decl) {
         CanUseCopyOrMoveName(decl, name)) {
       return name;
     }
-    return GetOverloadedFunctionName(decl);
+    return std::format("new_{}", GetCtorIndex(decl));
   }
   return GetNumberOfConvertingCtors(decl->getParent()) != 1
              ? std::format("new_{}", GetCtorIndex(decl))
@@ -4044,28 +4044,13 @@ std::string Converter::ConvertVarDefaultInit(clang::QualType qual_type) {
 }
 
 std::string
-Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
+Converter::GetOverloadedFunctionName(const clang::CXXMethodDecl *decl) {
   auto name = GetFunctionBaseName(decl);
   if (auto *conversion = clang::dyn_cast<clang::CXXConversionDecl>(decl)) {
     name = GetConversionName(
         conversion, GetUnsafeTypeAsString(conversion->getConversionType()));
   }
-  if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(decl);
-      ctor && !ctor->getParent()->getIdentifier()) {
-    name = GetRecordName(ctor->getParent());
-  }
-
-  if (decl->getNumParams() != 0U) {
-    name += '_';
-  }
-
-  for (auto *parameter : decl->parameters()) {
-    name += GetUnsafeTypeAsString(parameter->getType());
-    if (parameter->getType()->isRValueReferenceType()) {
-      name += "_rv";
-    }
-    name += '_';
-  }
+  name += std::format("_{}", GetMethodIndex(decl));
 
   if (const auto *targs = decl->getTemplateSpecializationArgs()) {
     std::vector<clang::TemplateArgument> args;
@@ -4094,31 +4079,6 @@ Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
     }
   }
 
-  auto pred = [](char ch) { return ch != ' ' && ch != '_'; };
-  name.erase(std::find_if(name.rbegin(), name.rend(), pred).base(), name.end());
-
-  if (decl->isVariadic()) {
-    name += "_va";
-  }
-  if (const auto *method = clang::dyn_cast<clang::CXXMethodDecl>(decl)) {
-    if (method->isConst()) {
-      name += "_const";
-    }
-    if (method->isVolatile()) {
-      name += "_volatile";
-    }
-    switch (method->getRefQualifier()) {
-    case clang::RQ_LValue:
-      name += "_lref";
-      break;
-    case clang::RQ_RValue:
-      name += "_rref";
-      break;
-    case clang::RQ_None:
-      break;
-    }
-  }
-
   ToIdentifier(name);
   return name;
 }

cpp2rust/converter/converter.h

@@ -583,7 +583,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual std::string ConvertVarDefaultInit(clang::QualType qual_type);
 
   virtual std::string
-  GetOverloadedFunctionName(const clang::FunctionDecl *decl);
+  GetOverloadedFunctionName(const clang::CXXMethodDecl *decl);
 
   virtual std::string GetRecordName(const clang::NamedDecl *decl) const;
 

cpp2rust/converter/converter_lib.cpp

@@ -352,6 +352,24 @@ bool IsOverloadedMethod(const clang::CXXMethodDecl *decl) {
                        }) > 1;
 }
 
+unsigned GetMethodIndex(const clang::CXXMethodDecl *decl) {
+  const clang::Decl *key = decl->getCanonicalDecl();
+  if (auto *tmpl = decl->getPrimaryTemplate()) {
+    key = tmpl->getCanonicalDecl();
+  }
+  unsigned index = 0;
+  for (auto *d : decl->getParent()->decls()) {
+    if (clang::isa<clang::CXXMethodDecl, clang::FunctionTemplateDecl>(d)) {
+      ++index;
+      if (d->getCanonicalDecl() == key) {
+        return index;
+      }
+    }
+  }
+  assert(false && "method not found in its record");
+  return 0;
+}
+
 const char *GetCopyOrMoveName(const clang::CXXMethodDecl *method) {
   if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(method)) {
     if (ctor->isCopyConstructor()) {

cpp2rust/converter/converter_lib.h

@@ -81,6 +81,8 @@ void ForEachTemplateInstantiatedMethod(
 
 bool IsOverloadedMethod(const clang::CXXMethodDecl *decl);
 
+unsigned GetMethodIndex(const clang::CXXMethodDecl *decl);
+
 const char *GetCopyOrMoveName(const clang::CXXMethodDecl *method);
 
 bool CanUseCopyOrMoveName(const clang::CXXMethodDecl *decl,

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

@@ -211,10 +211,10 @@ pub trait PartialImpl {
     fn get(&self) -> Ptr<i32> {
         unimplemented!()
     }
-    fn next(&self) -> Ptr<Partial> {
+    fn next_4(&self) -> Ptr<Partial> {
         unimplemented!()
     }
-    fn next_i32(&self, _a0: i32) -> Partial {
+    fn next_5(&self, _a0: i32) -> Partial {
         unimplemented!()
     }
 }

tests/unit/out/refcount/as_const.rs

@@ -49,39 +49,39 @@ fn main_0() -> i32 {
     let s: Value<S> = Rc::new(RefCell::new(S {
         v: Rc::new(RefCell::new(7)),
     }));
-    assert!(((({ SImpl::f(&s.as_pointer(),) }) as i32) == (Overload_kMutableOverload as i32)));
-    assert!(((({ SImpl::f_const(&s.as_pointer(),) }) as i32) == (Overload_kConstOverload as i32)));
+    assert!(((({ SImpl::f_1(&s.as_pointer(),) }) as i32) == (Overload_kMutableOverload as i32)));
+    assert!(((({ SImpl::f_2(&s.as_pointer(),) }) as i32) == (Overload_kConstOverload as i32)));
     assert!(((({ g_0(s.as_pointer(),) }) as i32) == (Overload_kMutableOverload as i32)));
     assert!(((({ g_1(s.as_pointer(),) }) as i32) == (Overload_kConstOverload as i32)));
-    ({ SImpl::value_ref(&s.as_pointer()) }).write(9);
+    ({ SImpl::value_ref_3(&s.as_pointer()) }).write(9);
     assert!(((*(*s.borrow()).v.borrow()) == 9));
-    assert!(((({ SImpl::value_ref_const(&s.as_pointer(),) }).read()) == 9));
+    assert!(((({ SImpl::value_ref_4(&s.as_pointer(),) }).read()) == 9));
     let cs: Ptr<S> = s.as_pointer();
-    assert!(((({ SImpl::f_const(&cs,) }) as i32) == (Overload_kConstOverload as i32)));
+    assert!(((({ SImpl::f_2(&cs,) }) as i32) == (Overload_kConstOverload as i32)));
     assert!(((*(*cs.upgrade().deref()).v.borrow()) == 9));
     let p: Value<Ptr<S>> = Rc::new(RefCell::new((s.as_pointer())));
     (*(*(*p.borrow()).upgrade().deref()).v.borrow_mut()) = 11;
     assert!(((*(*s.borrow()).v.borrow()) == 11));
-    assert!(((({ SImpl::f(&(*p.borrow()),) }) as i32) == (Overload_kMutableOverload as i32)));
+    assert!(((({ SImpl::f_1(&(*p.borrow()),) }) as i32) == (Overload_kMutableOverload as i32)));
     return 0;
 }
 pub trait SImpl {
-    fn f(&self) -> Overload;
-    fn f_const(&self) -> Overload;
-    fn value_ref(&self) -> Ptr<i32>;
-    fn value_ref_const(&self) -> Ptr<i32>;
+    fn f_1(&self) -> Overload;
+    fn f_2(&self) -> Overload;
+    fn value_ref_3(&self) -> Ptr<i32>;
+    fn value_ref_4(&self) -> Ptr<i32>;
 }
 impl SImpl for Ptr<S> {
-    fn f(&self) -> Overload {
+    fn f_1(&self) -> Overload {
         return Overload_kMutableOverload;
     }
-    fn f_const(&self) -> Overload {
+    fn f_2(&self) -> Overload {
         return Overload_kConstOverload;
     }
-    fn value_ref(&self) -> Ptr<i32> {
+    fn value_ref_3(&self) -> Ptr<i32> {
         return (*(*self).upgrade().deref()).v.as_pointer();
     }
-    fn value_ref_const(&self) -> Ptr<i32> {
+    fn value_ref_4(&self) -> Ptr<i32> {
         return (*(*self).upgrade().deref()).v.as_pointer();
     }
 }

tests/unit/out/refcount/class_templates.rs

@@ -346,7 +346,7 @@ fn main_0() -> i32 {
     });
     assert!(
         (({ MyContainer_int_Impl::size(&imc.as_pointer(),) }) == 1_usize)
-            && ((({ MyContainer_int_Impl::back(&imc.as_pointer(),) }).read()) == 1)
+            && ((({ MyContainer_int_Impl::back_4(&imc.as_pointer(),) }).read()) == 1)
     );
     ({ MyContainer_int_Impl::pop_back(&imc.as_pointer()) });
     assert!(({ MyContainer_int_Impl::empty(&imc.as_pointer(),) }));
@@ -358,7 +358,7 @@ fn main_0() -> i32 {
     });
     assert!(
         (({ MyContainer_char_Impl::size(&cmc.as_pointer(),) }) == 1_usize)
-            && (((({ MyContainer_char_Impl::back(&cmc.as_pointer(),) }).read()) as i32)
+            && (((({ MyContainer_char_Impl::back_4(&cmc.as_pointer(),) }).read()) as i32)
                 == (('a' as u8) as i32))
     );
     ({ MyContainer_char_Impl::pop_back(&cmc.as_pointer()) });
@@ -371,7 +371,8 @@ fn main_0() -> i32 {
     });
     assert!(
         (({ MyContainer_float_Impl::size(&fmc.as_pointer(),) }) == 1_usize)
-            && (((({ MyContainer_float_Impl::back(&fmc.as_pointer(),) }).read()) as f64) == 1.0E+0)
+            && (((({ MyContainer_float_Impl::back_4(&fmc.as_pointer(),) }).read()) as f64)
+                == 1.0E+0)
     );
     ({ MyContainer_float_Impl::pop_back(&fmc.as_pointer()) });
     assert!(({ MyContainer_float_Impl::empty(&fmc.as_pointer(),) }));
@@ -398,10 +399,10 @@ impl Boxed_long_Impl for Ptr<Boxed_long_> {
 pub trait MyContainer_char_Impl {
     fn empty(&self) -> bool;
     fn size(&self) -> usize;
-    fn back_const(&self) -> Ptr<u8> {
+    fn back_3(&self) -> Ptr<u8> {
         unimplemented!()
     }
-    fn back(&self) -> Ptr<u8>;
+    fn back_4(&self) -> Ptr<u8>;
     fn pop_back(&self);
     fn push_back(&self, item: Ptr<u8>);
 }
@@ -412,7 +413,7 @@ impl MyContainer_char_Impl for Ptr<MyContainer_char_> {
     fn size(&self) -> usize {
         return (*(*(*self).upgrade().deref()).vec_.borrow()).len();
     }
-    fn back(&self) -> Ptr<u8> {
+    fn back_4(&self) -> Ptr<u8> {
         return ((*(*self).upgrade().deref()).vec_.as_pointer() as Ptr<u8>).to_last();
     }
     fn pop_back(&self) {
@@ -429,10 +430,10 @@ impl MyContainer_char_Impl for Ptr<MyContainer_char_> {
 pub trait MyContainer_float_Impl {
     fn empty(&self) -> bool;
     fn size(&self) -> usize;
-    fn back_const(&self) -> Ptr<f32> {
+    fn back_3(&self) -> Ptr<f32> {
         unimplemented!()
     }
-    fn back(&self) -> Ptr<f32>;
+    fn back_4(&self) -> Ptr<f32>;
     fn pop_back(&self);
     fn push_back(&self, item: Ptr<f32>);
 }
@@ -443,7 +444,7 @@ impl MyContainer_float_Impl for Ptr<MyContainer_float_> {
     fn size(&self) -> usize {
         return (*(*(*self).upgrade().deref()).vec_.borrow()).len();
     }
-    fn back(&self) -> Ptr<f32> {
+    fn back_4(&self) -> Ptr<f32> {
         return ((*(*self).upgrade().deref()).vec_.as_pointer() as Ptr<f32>).to_last();
     }
     fn pop_back(&self) {
@@ -460,10 +461,10 @@ impl MyContainer_float_Impl for Ptr<MyContainer_float_> {
 pub trait MyContainer_int_Impl {
     fn empty(&self) -> bool;
     fn size(&self) -> usize;
-    fn back_const(&self) -> Ptr<i32> {
+    fn back_3(&self) -> Ptr<i32> {
         unimplemented!()
     }
-    fn back(&self) -> Ptr<i32>;
+    fn back_4(&self) -> Ptr<i32>;
     fn pop_back(&self);
     fn push_back(&self, item: Ptr<i32>);
 }
@@ -474,7 +475,7 @@ impl MyContainer_int_Impl for Ptr<MyContainer_int_> {
     fn size(&self) -> usize {
         return (*(*(*self).upgrade().deref()).vec_.borrow()).len();
     }
-    fn back(&self) -> Ptr<i32> {
+    fn back_4(&self) -> Ptr<i32> {
         return ((*(*self).upgrade().deref()).vec_.as_pointer() as Ptr<i32>).to_last();
     }
     fn pop_back(&self) {

tests/unit/out/refcount/copy_assign.rs

@@ -254,10 +254,8 @@ fn main_0() -> i32 {
     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())
-    });
+    ({ NonConstAssignImpl::operator_assign_2(&n1.as_pointer(), n.as_pointer()) });
+    ({ NonConstAssignImpl::operator_assign_3(&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::new()));
@@ -267,16 +265,16 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait NonConstAssignImpl {
-    fn operator_assign_pmutNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
-    fn operator_assign_pconstNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
+    fn operator_assign_2(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
+    fn operator_assign_3(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
 }
 impl NonConstAssignImpl for Ptr<NonConstAssign> {
-    fn operator_assign_pmutNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
+    fn operator_assign_2(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
         let __rhs = ((*(*o.upgrade().deref()).mark.borrow()) + 1);
         (*(*(*self).upgrade().deref()).mark.borrow_mut()) = __rhs;
         return (*self).clone();
     }
-    fn operator_assign_pconstNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
+    fn operator_assign_3(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign> {
         let __rhs = ((*(*o.upgrade().deref()).mark.borrow()) + 10);
         (*(*(*self).upgrade().deref()).mark.borrow_mut()) = __rhs;
         return (*self).clone();

tests/unit/out/refcount/copy_ctor.rs

@@ -62,14 +62,14 @@ impl NonConst {
         let this: Ptr<NonConst> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn NonConst_pmutNonConst(o: Ptr<NonConst>) -> Self {
+    pub fn new_1(o: Ptr<NonConst>) -> Self {
         let __this: Value<NonConst> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(((*(*o.upgrade().deref()).mark.borrow()) + 1))),
         }));
         let this: Ptr<NonConst> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
-    pub fn NonConst_pconstNonConst(o: Ptr<NonConst>) -> Self {
+    pub fn new_2(o: Ptr<NonConst>) -> Self {
         let __this: Value<NonConst> = Rc::new(RefCell::new(Self {
             mark: Rc::new(RefCell::new(((*(*o.upgrade().deref()).mark.borrow()) + 10))),
         }));
@@ -82,7 +82,7 @@ impl Clone for NonConst {
         let __src: Value<NonConst> = Rc::new(RefCell::new(NonConst {
             mark: self.mark.clone(),
         }));
-        NonConst::NonConst_pmutNonConst(__src.as_pointer())
+        NonConst::new_1(__src.as_pointer())
     }
 }
 impl Default for NonConst {
@@ -259,13 +259,9 @@ fn main_0() -> i32 {
     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::new()));
-    let n1: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_pmutNonConst({
-        n.as_pointer()
-    })));
+    let n1: Value<NonConst> = Rc::new(RefCell::new(NonConst::new_1({ n.as_pointer() })));
     let cn: Value<NonConst> = Rc::new(RefCell::new(NonConst::new()));
-    let n2: Value<NonConst> = Rc::new(RefCell::new(NonConst::NonConst_pconstNonConst({
-        cn.as_pointer()
-    })));
+    let n2: Value<NonConst> = Rc::new(RefCell::new(NonConst::new_2({ cn.as_pointer() })));
     assert!(((*(*n1.borrow()).mark.borrow()) == 1));
     assert!(((*(*n2.borrow()).mark.borrow()) == 10));
     return 0;

tests/unit/out/refcount/fn_ptr_struct.rs

@@ -57,11 +57,11 @@ pub fn negate_1(x: i32) -> i32 {
 #[derive(Clone, ByteRepr, VaArg, FnPtrArg, Default)]
 pub struct S {}
 impl S {
-    pub fn pick_i32(x: i32) -> i32 {
+    pub fn pick_1(x: i32) -> i32 {
         let x: Value<i32> = Rc::new(RefCell::new(x));
         return ((*x.borrow()) + 1);
     }
-    pub fn pick_i64(x: i64) -> i32 {
+    pub fn pick_2(x: i64) -> i32 {
         let x: Value<i64> = Rc::new(RefCell::new(x));
         return (((*x.borrow()) as i32) + 2);
     }
@@ -76,15 +76,15 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let p1: Value<FnPtr<fn(i32) -> i32>> =
-        Rc::new(RefCell::new((FnPtr::<fn(i32) -> i32>::new(S::pick_i32))));
+        Rc::new(RefCell::new((FnPtr::<fn(i32) -> i32>::new(S::pick_1))));
     let p2: Value<FnPtr<fn(i32) -> i32>> =
         Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(S::solo)));
     assert!((({ (*p1.borrow()).call(5,) }) == 6));
     assert!((({ (*p2.borrow()).call(5,) }) == 8));
-    assert!((({ S::pick_i64(5_i64,) }) == 7));
+    assert!((({ S::pick_2(5_i64,) }) == 7));
     let h3: Value<Handler> = Rc::new(RefCell::new(Handler {
         tag: Rc::new(RefCell::new(3)),
-        cb: Rc::new(RefCell::new((FnPtr::<fn(i32) -> i32>::new(S::pick_i32)))),
+        cb: Rc::new(RefCell::new((FnPtr::<fn(i32) -> i32>::new(S::pick_1)))),
     }));
     assert!((({ (*(*h3.borrow()).cb.borrow()).call(1,) }) == 2));
     let h1: Value<Handler> = Rc::new(RefCell::new(Handler {