Fix naming clash between functoins and specializations

Author: lucic71

cpp2rust/converter/converter_lib.cpp

@@ -535,13 +535,24 @@ static std::string GetParamSignature(const clang::Decl *decl) {
 }
 
 static std::string GetLexicalSpecializationID(const clang::Decl *decl) {
+  std::string id;
   if (const auto *spec =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(
               decl->getLexicalDeclContext());
       spec && decl->getLexicalDeclContext() != decl->getDeclContext()) {
-    return Mapper::ToString(Mapper::GetTypeForDecl(spec));
+    id += Mapper::ToString(Mapper::GetTypeForDecl(spec));
   }
-  return {};
+  for (const auto *dc = decl->getDeclContext(); dc; dc = dc->getParent()) {
+    if (const auto *spec =
+            clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(dc)) {
+      id += Mapper::ToString(Mapper::GetTypeForDecl(spec));
+    }
+    if (const auto *fn = clang::dyn_cast<clang::FunctionDecl>(dc);
+        fn && fn->getTemplateSpecializationArgs()) {
+      id += clang::ASTNameGenerator(fn->getASTContext()).getName(fn);
+    }
+  }
+  return id;
 }
 
 std::string GetID(const clang::Decl *decl) {
@@ -623,6 +634,10 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
              var && (var->isFileVarDecl() || var->isStaticLocal())) {
     id = GetDeclId(var->getCanonicalDecl(),
                    var->getFormalLinkage() != clang::Linkage::External);
+  } else if (auto *tag = clang::dyn_cast<clang::TagDecl>(decl);
+             tag && tag->getDeclContext()->isFunctionOrMethod()) {
+    id =
+        type_mapping.try_emplace(GetID(tag), type_mapping.size()).first->second;
   }
   if (id) {
     name += '_';

cpp2rust/converter/mapper.cpp

@@ -882,6 +882,12 @@ std::string ToString(clang::QualType qual_type, ScalarSugar sugar) {
     return ToString(clang::cast<clang::NamedDecl>(tag));
   }
 
+  if (auto *tag = qual_type->getAsTagDecl();
+      tag && tag->getIdentifier() &&
+      tag->getDeclContext()->isFunctionOrMethod()) {
+    return GetNamedDeclAsString(tag);
+  }
+
   if (auto renamed = DisambiguateAnonymousTag(qual_type->getAsTagDecl());
       !renamed.empty()) {
     return renamed;

tests/unit/local_record_template.cpp

@@ -6,12 +6,32 @@ namespace ns {
 template <typename T> int twice(T t) { return t.x * 2; }
 }
 
+template <typename T> int wrap(T v) {
+  struct Local {
+    T x;
+  };
+  Local l{v};
+  return get(l);
+}
+
+int other() {
+  struct Local {
+    long x;
+    long y;
+  };
+  Local l{3, 4};
+  return get(l) + (int)l.y;
+}
+
 int main() {
   struct Local {
     int x;
   };
   Local l{7};
   assert(get(l) == 7);
   assert(ns::twice(l) == 14);
+  assert(other() == 7);
+  assert(wrap(5) == 5);
+  assert(wrap(6L) == 6);
   return 0;
 }

tests/unit/out/refcount/local_record_template.rs

@@ -6,39 +6,157 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn get_0(t: Local) -> i32 {
-    let t: Value<Local> = Rc::new(RefCell::new(t));
+pub fn get_0(t: Local_1) -> i32 {
+    let t: Value<Local_1> = Rc::new(RefCell::new(t));
+    return ((*(*t.borrow()).x.borrow()) as i32);
+}
+pub fn get_2(t: Local_3) -> i32 {
+    let t: Value<Local_3> = Rc::new(RefCell::new(t));
+    return (*(*t.borrow()).x.borrow());
+}
+pub fn get_4(t: Local_5) -> i32 {
+    let t: Value<Local_5> = Rc::new(RefCell::new(t));
     return (*(*t.borrow()).x.borrow());
 }
-pub fn twice_1(t: Local) -> i32 {
-    let t: Value<Local> = Rc::new(RefCell::new(t));
+pub fn get_6(t: Local_7) -> i32 {
+    let t: Value<Local_7> = Rc::new(RefCell::new(t));
+    return ((*(*t.borrow()).x.borrow()) as i32);
+}
+pub fn twice_8(t: Local_3) -> i32 {
+    let t: Value<Local_3> = Rc::new(RefCell::new(t));
     return ((*(*t.borrow()).x.borrow()) * 2);
 }
+pub fn wrap_9(v: i32) -> i32 {
+    let v: Value<i32> = Rc::new(RefCell::new(v));
+    let l: Value<Local_5> = Rc::new(RefCell::new(Local_5 {
+        x: Rc::new(RefCell::new((*v.borrow()))),
+    }));
+    return ({ get_4((*l.borrow()).clone()) });
+}
+pub fn wrap_10(v: i64) -> i32 {
+    let v: Value<i64> = Rc::new(RefCell::new(v));
+    let l: Value<Local_7> = Rc::new(RefCell::new(Local_7 {
+        x: Rc::new(RefCell::new((*v.borrow()))),
+    }));
+    return ({ get_6((*l.borrow()).clone()) });
+}
+#[derive(Default)]
+pub struct Local_5 {
+    pub x: Value<i32>,
+}
+impl Clone for Local_5 {
+    fn clone(&self) -> Self {
+        let __this: Value<Local_5> = Rc::new(RefCell::new(Self {
+            x: Rc::new(RefCell::new((*self.x.borrow()))),
+        }));
+        let this: Ptr<Local_5> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Local_5 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Local_7 {
+    pub x: Value<i64>,
+}
+impl Clone for Local_7 {
+    fn clone(&self) -> Self {
+        let __this: Value<Local_7> = Rc::new(RefCell::new(Self {
+            x: Rc::new(RefCell::new((*self.x.borrow()))),
+        }));
+        let this: Ptr<Local_7> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Local_7 {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i64>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
+pub fn other_11() -> i32 {
+    let l: Value<Local_1> = Rc::new(RefCell::new(Local_1 {
+        x: Rc::new(RefCell::new(3_i64)),
+        y: Rc::new(RefCell::new(4_i64)),
+    }));
+    return (({ get_0((*l.borrow()).clone()) }) + ((*(*l.borrow()).y.borrow()) as i32));
+}
+#[derive(Default)]
+pub struct Local_1 {
+    pub x: Value<i64>,
+    pub y: Value<i64>,
+}
+impl Clone for Local_1 {
+    fn clone(&self) -> Self {
+        let __this: Value<Local_1> = Rc::new(RefCell::new(Self {
+            x: Rc::new(RefCell::new((*self.x.borrow()))),
+            y: Rc::new(RefCell::new((*self.y.borrow()))),
+        }));
+        let this: Ptr<Local_1> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Local_1 {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.y.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i64>::from_bytes(&buf[0..8]))),
+            y: Rc::new(RefCell::new(<i64>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let l: Value<Local> = Rc::new(RefCell::new(Local {
+    let l: Value<Local_3> = Rc::new(RefCell::new(Local_3 {
         x: Rc::new(RefCell::new(7)),
     }));
-    assert!((({ get_0((*l.borrow()).clone(),) }) == 7));
-    assert!((({ twice_1((*l.borrow()).clone(),) }) == 14));
+    assert!((({ get_2((*l.borrow()).clone(),) }) == 7));
+    assert!((({ twice_8((*l.borrow()).clone(),) }) == 14));
+    assert!((({ other_11() }) == 7));
+    assert!((({ wrap_9(5,) }) == 5));
+    assert!((({ wrap_10(6_i64,) }) == 6));
     return 0;
 }
 #[derive(Default)]
-pub struct Local {
+pub struct Local_3 {
     pub x: Value<i32>,
 }
-impl Clone for Local {
+impl Clone for Local_3 {
     fn clone(&self) -> Self {
-        let __this: Value<Local> = Rc::new(RefCell::new(Self {
+        let __this: Value<Local_3> = Rc::new(RefCell::new(Self {
             x: Rc::new(RefCell::new((*self.x.borrow()))),
         }));
-        let this: Ptr<Local> = __this.as_pointer();
+        let this: Ptr<Local_3> = __this.as_pointer();
         Rc::try_unwrap(__this).ok().unwrap().into_inner()
     }
 }
-impl ByteRepr for Local {
+impl ByteRepr for Local_3 {
     fn byte_size() -> usize {
         4
     }

tests/unit/out/unsafe/local_record_template.rs

@@ -6,25 +6,65 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn get_0(mut t: Local) -> i32 {
+pub unsafe fn get_0(mut t: Local_1) -> i32 {
+    return (t.x as i32);
+}
+pub unsafe fn get_2(mut t: Local_3) -> i32 {
+    return t.x;
+}
+pub unsafe fn get_4(mut t: Local_5) -> i32 {
     return t.x;
 }
-pub unsafe fn twice_1(mut t: Local) -> i32 {
+pub unsafe fn get_6(mut t: Local_7) -> i32 {
+    return (t.x as i32);
+}
+pub unsafe fn twice_8(mut t: Local_3) -> i32 {
     return ((t.x) * (2));
 }
+pub unsafe fn wrap_9(mut v: i32) -> i32 {
+    let mut l: Local_5 = Local_5 { x: v };
+    return (unsafe { get_4(l) });
+}
+pub unsafe fn wrap_10(mut v: i64) -> i32 {
+    let mut l: Local_7 = Local_7 { x: v };
+    return (unsafe { get_6(l) });
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Local_5 {
+    pub x: i32,
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Local_7 {
+    pub x: i64,
+}
+pub unsafe fn other_11() -> i32 {
+    let mut l: Local_1 = Local_1 { x: 3_i64, y: 4_i64 };
+    return ((unsafe { get_0(l) }) + (l.y as i32));
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Local_1 {
+    pub x: i64,
+    pub y: i64,
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut l: Local = Local { x: 7 };
-    assert!(((unsafe { get_0(l,) }) == (7)));
-    assert!(((unsafe { twice_1(l,) }) == (14)));
+    let mut l: Local_3 = Local_3 { x: 7 };
+    assert!(((unsafe { get_2(l,) }) == (7)));
+    assert!(((unsafe { twice_8(l,) }) == (14)));
+    assert!(((unsafe { other_11() }) == (7)));
+    assert!(((unsafe { wrap_9(5,) }) == (5)));
+    assert!(((unsafe { wrap_10(6_i64,) }) == (6)));
     return 0;
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
-pub struct Local {
+pub struct Local_3 {
     pub x: i32,
 }