Fix translation of out-of-line template static methods (#393)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1054,7 +1054,8 @@ bool Converter::VisitCXXMethodDecl(clang::CXXMethodDecl *decl) {
   if (!ShouldConvertMethod(decl)) {
     return false;
   }
-  if (!decl->isPureVirtual() && !decl->hasBody()) {
+  if (decl->getDescribedFunctionTemplate() || decl->isDependentContext() ||
+      (!decl->isPureVirtual() && !decl->hasBody())) {
     return false;
   }
   if (!decl_ids_.insert(GetMethodID(decl)).second) {
@@ -1065,7 +1066,7 @@ bool Converter::VisitCXXMethodDecl(clang::CXXMethodDecl *decl) {
   if (decl->isOutOfLine() && !decl->overridden_methods().empty()) {
     return false;
   }
-  if (decl->isOutOfLine()) {
+  if (decl->isOutOfLine() && !decl->isTemplateInstantiation()) {
     return ConvertOutOfLineMethod(decl);
   }
   return ConvertCXXMethodDecl(decl);

tests/unit/class_templates.cpp

@@ -18,7 +18,25 @@ template <typename T> class MyContainer {
   void push_back(const_reference item) { vec.push_back(item); }
 };
 
+template <typename T> struct Boxed {
+  T value;
+  static T twice(T v);
+  T plus(T other) const;
+};
+
+template <typename T> T Boxed<T>::twice(T v) { return v + v; }
+
+template <typename T> T Boxed<T>::plus(T other) const { return value + other; }
+
 int main() {
+  assert(Boxed<int>::twice(3) == 6);
+  Boxed<int> bi{4};
+  assert(bi.plus(5) == 9);
+
+  assert(Boxed<long>::twice(10) == 20);
+  Boxed<long> bl{7};
+  assert(bl.plus(1) == 8);
+
   MyContainer<int> imc;
   assert(imc.empty());
   imc.push_back(1);

tests/unit/out/refcount/class_templates.rs

@@ -84,11 +84,85 @@ impl ByteRepr for MyContainer_float_ {
         }
     }
 }
+#[derive(Default)]
+pub struct Boxed_int_ {
+    pub value: Value<i32>,
+}
+impl Boxed_int_ {
+    pub fn twice(v: i32) -> i32 {
+        let v: Value<i32> = Rc::new(RefCell::new(v));
+        return ((*v.borrow()) + (*v.borrow()));
+    }
+}
+impl Clone for Boxed_int_ {
+    fn clone(&self) -> Self {
+        let __this: Value<Boxed_int_> = Rc::new(RefCell::new(Self {
+            value: Rc::new(RefCell::new((*self.value.borrow()))),
+        }));
+        let this: Ptr<Boxed_int_> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Boxed_int_ {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.value.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            value: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Boxed_long_ {
+    pub value: Value<i64>,
+}
+impl Boxed_long_ {
+    pub fn twice(v: i64) -> i64 {
+        let v: Value<i64> = Rc::new(RefCell::new(v));
+        return ((*v.borrow()) + (*v.borrow()));
+    }
+}
+impl Clone for Boxed_long_ {
+    fn clone(&self) -> Self {
+        let __this: Value<Boxed_long_> = Rc::new(RefCell::new(Self {
+            value: Rc::new(RefCell::new((*self.value.borrow()))),
+        }));
+        let this: Ptr<Boxed_long_> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Boxed_long_ {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.value.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            value: Rc::new(RefCell::new(<i64>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
+    assert!((({ Boxed_int_::twice(3,) }) == 6));
+    let bi: Value<Boxed_int_> = Rc::new(RefCell::new(Boxed_int_ {
+        value: Rc::new(RefCell::new(4)),
+    }));
+    assert!((({ Boxed_int_Impl::plus(&bi.as_pointer(), 5,) }) == 9));
+    assert!((({ Boxed_long_::twice(10_i64,) }) == 20_i64));
+    let bl: Value<Boxed_long_> = Rc::new(RefCell::new(Boxed_long_ {
+        value: Rc::new(RefCell::new(7_i64)),
+    }));
+    assert!((({ Boxed_long_Impl::plus(&bl.as_pointer(), 1_i64,) }) == 8_i64));
     let imc: Value<MyContainer_int_> = Rc::new(RefCell::new(<MyContainer_int_>::default()));
     assert!(({ MyContainer_int_Impl::empty(&imc.as_pointer(),) }));
     ({
@@ -128,6 +202,24 @@ fn main_0() -> i32 {
     assert!(({ MyContainer_float_Impl::empty(&fmc.as_pointer(),) }));
     return 0;
 }
+pub trait Boxed_int_Impl {
+    fn plus(&self, other: i32) -> i32;
+}
+impl Boxed_int_Impl for Ptr<Boxed_int_> {
+    fn plus(&self, other: i32) -> i32 {
+        let other: Value<i32> = Rc::new(RefCell::new(other));
+        return ((*(*(*self).upgrade().deref()).value.borrow()) + (*other.borrow()));
+    }
+}
+pub trait Boxed_long_Impl {
+    fn plus(&self, other: i64) -> i64;
+}
+impl Boxed_long_Impl for Ptr<Boxed_long_> {
+    fn plus(&self, other: i64) -> i64 {
+        let other: Value<i64> = Rc::new(RefCell::new(other));
+        return ((*(*(*self).upgrade().deref()).value.borrow()) + (*other.borrow()));
+    }
+}
 pub trait MyContainer_char_Impl {
     fn empty(&self) -> bool;
     fn size(&self) -> usize;

tests/unit/out/unsafe/class_templates.rs

@@ -84,13 +84,45 @@ impl MyContainer_float_ {
         };
     }
 }
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Boxed_int_ {
+    pub value: i32,
+}
+impl Boxed_int_ {
+    pub unsafe fn twice(mut v: i32) -> i32 {
+        return ((v) + (v));
+    }
+    pub unsafe fn plus(&self, mut other: i32) -> i32 {
+        return ((self.value) + (other));
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Boxed_long_ {
+    pub value: i64,
+}
+impl Boxed_long_ {
+    pub unsafe fn twice(mut v: i64) -> i64 {
+        return ((v) + (v));
+    }
+    pub unsafe fn plus(&self, mut other: i64) -> i64 {
+        return ((self.value) + (other));
+    }
+}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
+    assert!(((unsafe { Boxed_int_::twice(3,) }) == (6)));
+    let mut bi: Boxed_int_ = Boxed_int_ { value: 4 };
+    assert!(((unsafe { Boxed_int_::plus(&bi, 5,) }) == (9)));
+    assert!(((unsafe { Boxed_long_::twice(10_i64,) }) == (20_i64)));
+    let mut bl: Boxed_long_ = Boxed_long_ { value: 7_i64 };
+    assert!(((unsafe { Boxed_long_::plus(&bl, 1_i64,) }) == (8_i64)));
     let mut imc: MyContainer_int_ = <MyContainer_int_>::default();
     assert!((unsafe { MyContainer_int_::empty(&imc,) }));
     (unsafe {