Translate inner templates

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -823,6 +823,12 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
         }
       }
     }
+    if (auto *nested_tmpl = clang::dyn_cast<clang::ClassTemplateDecl>(d)) {
+      for (auto *spec : nested_tmpl->specializations()) {
+        inner_structs_[GetID(spec)] = GetRecordName(spec);
+        VisitCXXRecordDecl(spec);
+      }
+    }
   }
 
   if (decl->isUnion()) {

cpp2rust/converter/converter_lib.cpp

@@ -595,6 +595,10 @@ static std::string GetLexicalSpecializationID(const clang::Decl *decl) {
           clang::dyn_cast<clang::VarTemplateSpecializationDecl>(decl)) {
     id += clang::ASTNameGenerator(var->getASTContext()).getName(var);
   }
+  if (const auto *self =
+          clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
+    id += Mapper::ToString(Mapper::GetTypeForDecl(self));
+  }
   if (const auto *spec =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(
               decl->getLexicalDeclContext());

tests/unit/out/refcount/class_templates.rs

@@ -235,6 +235,36 @@ impl ByteRepr for Outer_long__Inner_int_ {
     }
 }
 #[derive(Default)]
+pub struct Outer_long__Inner_char_ {
+    pub t: Value<i64>,
+    pub u: Value<u8>,
+}
+impl Clone for Outer_long__Inner_char_ {
+    fn clone(&self) -> Self {
+        let __this: Value<Outer_long__Inner_char_> = Rc::new(RefCell::new(Self {
+            t: Rc::new(RefCell::new((*self.t.borrow()))),
+            u: Rc::new(RefCell::new((*self.u.borrow()))),
+        }));
+        let this: Ptr<Outer_long__Inner_char_> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Outer_long__Inner_char_ {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.t.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.u.borrow()).to_bytes(&mut buf[8..9]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            t: Rc::new(RefCell::new(<i64>::from_bytes(&buf[0..8]))),
+            u: Rc::new(RefCell::new(<u8>::from_bytes(&buf[8..9]))),
+        }
+    }
+}
+#[derive(Default)]
 pub struct Outer_long_ {
     pub v: Value<i64>,
 }
@@ -296,7 +326,7 @@ fn main_0() -> i32 {
         }) == 7)
     );
     assert!(
-        (({ Outer_long__Inner_int_Impl::sum(&ic.as_pointer(),) }) == (6 + (('a' as u8) as i32)))
+        (({ Outer_long__Inner_char_Impl::sum(&ic.as_pointer(),) }) == (6 + (('a' as u8) as i32)))
     );
     assert!((({ Boxed_int_::twice(3,) }) == 6));
     let bi: Value<Boxed_int_> = Rc::new(RefCell::new(Boxed_int_ {
@@ -491,14 +521,19 @@ impl Outer_long_Impl for Ptr<Outer_long_> {
         };
     }
 }
-pub trait Outer_long__Inner_int_Impl {
+pub trait Outer_long__Inner_char_Impl {
     fn sum(&self) -> i32;
 }
-impl Outer_long__Inner_int_Impl for Ptr<Outer_long__Inner_int_> {
+impl Outer_long__Inner_char_Impl for Ptr<Outer_long__Inner_char_> {
     fn sum(&self) -> i32 {
         return (((*(*(*self).upgrade().deref()).t.borrow()) as i32)
             + ((*(*(*self).upgrade().deref()).u.borrow()) as i32));
     }
+}
+pub trait Outer_long__Inner_int_Impl {
+    fn sum(&self) -> i32;
+}
+impl Outer_long__Inner_int_Impl for Ptr<Outer_long__Inner_int_> {
     fn sum(&self) -> i32 {
         return (((*(*(*self).upgrade().deref()).t.borrow()) as i32)
             + ((*(*(*self).upgrade().deref()).u.borrow()) as i32));

tests/unit/out/unsafe/class_templates.rs

@@ -142,7 +142,13 @@ impl Outer_long__Inner_int_ {
         return ((self.t as i32) + (self.u as i32));
     }
 }
-impl Outer_long__Inner_int_ {
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Outer_long__Inner_char_ {
+    pub t: i64,
+    pub u: libc::c_char,
+}
+impl Outer_long__Inner_char_ {
     pub unsafe fn sum(&self) -> i32 {
         return ((self.t as i32) + (self.u as i32));
     }
@@ -178,7 +184,7 @@ unsafe fn main_0() -> i32 {
             == (7))
     );
     assert!(
-        ((unsafe { Outer_long__Inner_int_::sum(&ic,) }) == ((6) + (('a' as libc::c_char) as i32)))
+        ((unsafe { Outer_long__Inner_char_::sum(&ic,) }) == ((6) + (('a' as libc::c_char) as i32)))
     );
     assert!(((unsafe { Boxed_int_::twice(3,) }) == (6)));
     let mut bi: Boxed_int_ = Boxed_int_ { value: 4 };