Don't genrate traits for non-instantiated methods

Author: lucic71

tests/unit/operator_traits.cpp

@@ -27,7 +27,20 @@ struct Free {
 bool operator<(const Free &a, const Free &b) { return a.v < b.v; }
 bool operator==(const Free &a, const Free &b) { return a.v == b.v; }
 
+template <class T> struct Wrapped {
+  T v;
+  friend bool operator==(const Wrapped &a, const Wrapped &b) {
+    return a.v == b.v;
+  }
+  friend bool operator<(const Wrapped &a, const Wrapped &b) {
+    return a.v < b.v;
+  }
+};
+
 int main() {
+  Wrapped<int> w{2};
+  assert(w.v == 2);
+
   std::vector<Lt> lts{{3}, {1}, {2}};
   std::sort(lts.begin(), lts.end());
   assert(lts[0].v == 1 && lts[1].v == 2 && lts[2].v == 3);

tests/unit/out/refcount/operator_traits.rs

@@ -232,10 +232,40 @@ pub fn operator_eq_1(a: Ptr<Free>, b: Ptr<Free>) -> bool {
         _lhs == (*(*b.upgrade().deref()).v.borrow())
     };
 }
+#[derive(Default)]
+pub struct Wrapped_int_ {
+    pub v: Value<i32>,
+}
+impl Clone for Wrapped_int_ {
+    fn clone(&self) -> Self {
+        let __this: Value<Wrapped_int_> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*self.v.borrow()))),
+        }));
+        let this: Ptr<Wrapped_int_> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Wrapped_int_ {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
+    let w: Value<Wrapped_int_> = Rc::new(RefCell::new(Wrapped_int_ {
+        v: Rc::new(RefCell::new(2)),
+    }));
+    assert!(((*(*w.borrow()).v.borrow()) == 2));
     let lts: Value<Vec<Lt>> = Rc::new(RefCell::new(vec![
         Lt {
             v: Rc::new(RefCell::new(3)),

tests/unit/out/unsafe/operator_traits.rs

@@ -123,12 +123,19 @@ pub unsafe fn operator_lt_0(a: *const Free, b: *const Free) -> bool {
 pub unsafe fn operator_eq_1(a: *const Free, b: *const Free) -> bool {
     return (((*a).v) == ((*b).v));
 }
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Wrapped_int_ {
+    pub v: i32,
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
+    let mut w: Wrapped_int_ = Wrapped_int_ { v: 2 };
+    assert!(((w.v) == (2)));
     let mut lts: Vec<Lt> = vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }];
     {
         let len = lts