Use counter based naming for overloads

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1157,7 +1157,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))
@@ -4106,25 +4106,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 += GetOverloadParamTypeAsString(parameter->getType());
-    name += '_';
-  }
+  name += std::format("_{}", GetMethodIndex(decl));
 
   if (const auto *targs = decl->getTemplateSpecializationArgs()) {
     std::vector<clang::TemplateArgument> args;
@@ -4153,31 +4141,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;
 }
@@ -4220,19 +4183,6 @@ std::string Converter::GetUnsafeTypeAsString(clang::QualType qual_type) const {
   return std::string(Trim(type_as_string));
 }
 
-std::string
-Converter::GetOverloadParamTypeAsString(clang::QualType type) const {
-  auto str = GetUnsafeTypeAsString(type);
-  if ((type->isPointerType() || type->isReferenceType()) &&
-      type->getPointeeType().isConstQualified()) {
-    str += "_const";
-  }
-  if (type->isRValueReferenceType()) {
-    str += "_rv";
-  }
-  return str;
-}
-
 void Converter::ConvertVarInit(clang::QualType qual_type, clang::Expr *expr) {
   if (qual_type->isReferenceType() && !IsReferenceType(expr)) {
     if (llvm::isa<clang::MaterializeTemporaryExpr>(expr->IgnoreImpCasts())) {

cpp2rust/converter/converter.h

@@ -580,7 +580,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;
 
@@ -589,8 +589,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual std::string GetUnsafeTypeAsString(clang::QualType qual_type) const;
 
-  virtual std::string GetOverloadParamTypeAsString(clang::QualType type) const;
-
   virtual bool NeedsMut(const clang::VarDecl *decl, clang::QualType type,
                         llvm::StringRef name) 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,

cpp2rust/converter/models/converter_refcount.cpp

@@ -133,19 +133,6 @@ ConverterRefCount::GetSafeTypeAsString(clang::QualType qual_type) const {
   return std::string(Trim(type_as_string));
 }
 
-std::string
-ConverterRefCount::GetOverloadParamTypeAsString(clang::QualType type) const {
-  auto str = GetSafeTypeAsString(type);
-  if ((type->isPointerType() || type->isReferenceType()) &&
-      type->getPointeeType().isConstQualified()) {
-    str += "_const";
-  }
-  if (type->isRValueReferenceType()) {
-    str += "_rv";
-  }
-  return str;
-}
-
 bool ConverterRefCount::NeedsMut(const clang::VarDecl *decl,
                                  clang::QualType type,
                                  llvm::StringRef /*name*/) const {

cpp2rust/converter/models/converter_refcount.h

@@ -330,8 +330,6 @@ class ConverterRefCount final : public Converter {
 
   std::string GetSafeTypeAsString(clang::QualType qual_type) const;
 
-  std::string GetOverloadParamTypeAsString(clang::QualType type) const override;
-
   bool NeedsMut(const clang::VarDecl *decl, clang::QualType type,
                 llvm::StringRef /*name*/) const override;
 

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,13 +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_PtrNonConstAssign(&n1.as_pointer(), n.as_pointer()) });
-    ({
-        NonConstAssignImpl::operator_assign_PtrNonConstAssign_const(
-            &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()));
@@ -270,22 +265,16 @@ fn main_0() -> i32 {
     return 0;
 }
 pub trait NonConstAssignImpl {
-    fn operator_assign_PtrNonConstAssign(&self, o: Ptr<NonConstAssign>) -> Ptr<NonConstAssign>;
-    fn operator_assign_PtrNonConstAssign_const(
-        &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_PtrNonConstAssign(&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_PtrNonConstAssign_const(
-        &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();