Fix Rc

Author: ryo33

README.md

@@ -375,3 +375,24 @@ impl Iterator for MockIterator {
     }
 }
 ```
+
+### Mocking non-Send types
+
+Mry supports types that don't implement `Send` for both in arguments and return type by wrapping them in [`SendWrapper`](https://docs.rs/send_wrapper/latest/send_wrapper/index.html) in the background. If you need working with non-Send types, you have to specify `#[mry::mry(not_send(Your::Type::Path, Another::Type::Path))]` for non-`Send` types other than raw pointers. Raw pointers are wrapped always with no configuration.
+
+```rust
+#[mry::mry(not_send(Rc, NotSendValue))] // You cannot write generics fields here like `Rc<String>`
+impl DataHandler {
+    fn process_raw_ptr(&self, ptr: *mut String) -> bool {
+        // implementation...
+    }
+
+    fn returns_non_send_type(&self) -> Rc<String> {
+        // implementation...
+    }
+
+    fn your_non_send_type(&self, value: NotSendValue) {
+        // implementation...
+    }
+}
+```

mry/src/mockable.rs

@@ -1,12 +1,12 @@
 #[diagnostic::on_unimplemented(
     message = "`{Self}` is not mockable argument because it is not `Send + 'static`",
-    // note = "If you don't need to mock this argument, you can add it to the skip list: `#[mry::mry(skip({Self}))]`"
+    note = "Consider `#[mry::mry(not_send(Rc, YourNotSendType))]`"
 )]
 pub trait MockableArg: Send + 'static {}
 
 #[diagnostic::on_unimplemented(
     message = "`{Self}` is not mockable output because it is not `Send + 'static`",
-    // note = "If you don't need to mock this argument, you can add it to the skip list: `#[mry::mry(skip({Self}))]`"
+    note = "Consider `#[mry::mry(not_send(Rc, YourNotSendType))]`"
 )]
 pub trait MockableRet: Send + 'static {}
 

mry/tests/integration/main.rs

@@ -19,5 +19,7 @@ mod returns_with_recursive_call;
 mod simple_case;
 mod static_function;
 
+#[cfg(feature = "send_wrapper")]
+mod non_send;
 #[cfg(feature = "send_wrapper")]
 mod raw_pointer;

mry/tests/integration/non_send.rs

@@ -0,0 +1,69 @@
+use std::rc::Rc;
+
+#[derive(Debug, Clone, PartialEq)]
+struct A(*const ());
+#[derive(Debug, Clone, PartialEq)]
+struct B;
+
+#[mry::mry]
+#[derive(Default)]
+struct Cat {
+    #[expect(dead_code)]
+    name: String,
+}
+
+#[mry::mry(not_send(A, Rc))]
+impl Cat {
+    fn meow_a(&self, a: A) -> String {
+        "meow".to_string()
+    }
+
+    fn meow_rc(&self) -> Rc<String> {
+        Rc::new("meow".to_string())
+    }
+
+    fn meow_b(&self, b: B) -> B {
+        b
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ptr::null;
+
+    use mry::send_wrapper::SendWrapper;
+
+    use super::*;
+
+    #[test]
+    fn test_meow_a() {
+        let mut cat = Cat {
+            name: "meow".to_string(),
+            ..Default::default()
+        };
+        cat.mock_meow_a(A(null()))
+            .returns_with(|_: SendWrapper<A>| "mocked".to_string());
+        assert_eq!(cat.meow_a(A(null())), "mocked");
+    }
+
+    #[test]
+    fn test_meow_rc() {
+        let mut cat = Cat {
+            name: "meow".to_string(),
+            ..Default::default()
+        };
+        cat.mock_meow_rc()
+            .returns_with(|| Rc::new("mocked".to_string()));
+        assert_eq!(cat.meow_rc(), Rc::new("mocked".to_string()));
+    }
+
+    #[test]
+    fn test_meow_b() {
+        let mut cat = Cat {
+            name: "meow".to_string(),
+            ..Default::default()
+        };
+        cat.mock_meow_b(B).returns_with(|_: B| B);
+        assert_eq!(cat.meow_b(B), B);
+    }
+}

mry_macros/src/attrs.rs

@@ -39,6 +39,18 @@ impl MryAttr {
                 }
                 if self.not_send.0.iter().any(|p| p == path) {
                     self.found = true;
+                    return;
+                }
+                for segment in path.segments.iter() {
+                    self.visit_path_segment(segment);
+                }
+            }
+            fn visit_ident(&mut self, ident: &syn::Ident) {
+                if self.found {
+                    return;
+                }
+                if self.not_send.0.iter().any(|p| p.is_ident(ident)) {
+                    self.found = true;
                 }
             }
         }
@@ -78,11 +90,37 @@ mod tests {
             .unwrap(),
         )
         .unwrap();
-        assert!(attr.debug.is_present());
-        assert!(matches!(attr.not_send, Some(NotSend(_))));
-        let lists = attr.not_send.as_ref().unwrap().0.clone();
+        let lists = attr.not_send.unwrap().0;
         assert_eq!(lists.len(), 2);
         assert_eq!(lists[0], parse_quote!(T));
         assert_eq!(lists[1], parse_quote!(U));
     }
+
+    #[test]
+    fn test_not_send_path() {
+        let attr = MryAttr::from_list(
+            &NestedMeta::parse_meta_list(parse_quote! {
+                debug,not_send(A::B)
+            })
+            .unwrap(),
+        )
+        .unwrap();
+
+        assert!(attr.test_non_send(&parse_quote!(A::B)));
+        assert!(!attr.test_non_send(&parse_quote!(A::C)));
+    }
+
+    #[test]
+    fn test_not_send_rc() {
+        let attr = MryAttr::from_list(
+            &NestedMeta::parse_meta_list(parse_quote! {
+                debug,not_send(Rc)
+            })
+            .unwrap(),
+        )
+        .unwrap();
+
+        assert!(attr.test_non_send(&parse_quote!(Rc<String>)));
+        assert!(!attr.test_non_send(&parse_quote!(String)));
+    }
 }

mry_macros/src/method.rs

@@ -446,8 +446,14 @@ mod test {
             "mry::send_wrapper::SendWrapper::new(<A::B>::clone(&var))"
         );
         let (owned_type, converter) = make_owned_type(&attr, &ident, &c_d);
-        assert_eq!(owned_type, parse_quote!(C::D));
-        assert_eq!(remove_spaces(&converter.to_string()), "<C::D>::clone(&var)");
+        assert_eq!(
+            owned_type,
+            parse_quote!(mry::send_wrapper::SendWrapper<C::D>)
+        );
+        assert_eq!(
+            remove_spaces(&converter.to_string()),
+            "mry::send_wrapper::SendWrapper::new(<C::D>::clone(&var))"
+        );
     }
 
     #[test]
@@ -538,7 +544,10 @@ mod test {
             remove_spaces(&a_b_type.static_type.to_string()),
             "mry::send_wrapper::SendWrapper<A::B>"
         );
-        assert_eq!(remove_spaces(&c_d_type.static_type.to_string()), "C::D");
+        assert_eq!(
+            remove_spaces(&c_d_type.static_type.to_string()),
+            "mry::send_wrapper::SendWrapper<C::D>"
+        );
         assert_eq!(a_type.behavior_type.to_string(), "A");
         assert_eq!(remove_spaces(&a_b_type.behavior_type.to_string()), "A::B");
         assert_eq!(remove_spaces(&c_d_type.behavior_type.to_string()), "C::D");