Add Sync support (#40)

Add `Sync` argument which marks the returned `Future` as `Sync`

Author: dcchut

.github/workflows/ci.yml

@@ -20,6 +20,8 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rust-src  # required for consistent error messages
       - run: cargo install cargo-expand
       - run: cargo test --verbose
 

README.md

@@ -52,25 +52,35 @@ async fn fib(n : u32) -> u32 {
 }
 ```
 
-## ?Send Option
+## ?Send option
 
-The returned future has a `Send` bound to make sure it can be sent between threads.
+The returned `Future` has a `Send` bound to make sure it can be sent between threads.
 If this is undesirable you can mark that the bound should be left out like so:
 
 ```rust
 #[async_recursion(?Send)]
-async fn example() {
+async fn returned_future_is_not_send() {
    // ...
 }
 ```
 
-In detail:
+## Sync option
+
+The returned `Future` doesn't have a `Sync` bound as it is usually not required. 
+You can include a `Sync` bound as follows:
+
+```rust
+#[async_recursion(Sync)]
+async fn returned_future_is_sync() {
+   // ...
+}
+```
 
-- `#[async_recursion]` modifies your function to return a [`BoxFuture`], and
-- `#[async_recursion(?Send)]` modifies your function to return a [`LocalBoxFuture`].
+In detail:
 
-[`BoxFuture`]: https://docs.rs/futures/0.3.19/futures/future/type.BoxFuture.html
-[`LocalBoxFuture`]: https://docs.rs/futures/0.3.19/futures/future/type.LocalBoxFuture.html
+- `#[async_recursion]` modifies your function to return a boxed `Future` with a `Send` bound.
+- `#[async_recursion(?Send)]` modifies your function to return a boxed `Future` _without_ a `Send` bound.
+- `#[async_recursion(Sync)]` modifies your function to return a boxed `Future` with a `Send` and `Sync` bound.
 
 ### License
 

src/expand.rs

@@ -173,6 +173,12 @@ fn transform_sig(sig: &mut Signature, args: &RecursionArgs) {
         quote!()
     };
 
+    let sync_bound: TokenStream = if args.sync_bound {
+        quote!(+ ::core::marker::Sync)
+    } else {
+        quote!()
+    };
+
     let where_clause = sig
         .generics
         .where_clause
@@ -196,6 +202,6 @@ fn transform_sig(sig: &mut Signature, args: &RecursionArgs) {
     // Modify the return type
     sig.output = parse_quote! {
         -> ::core::pin::Pin<Box<
-            dyn ::core::future::Future<Output = #ret> #box_lifetime #send_bound >>
+            dyn ::core::future::Future<Output = #ret> #box_lifetime #send_bound #sync_bound>>
     };
 }

src/lib.rs

@@ -52,27 +52,40 @@
 //! }
 //! ```
 //!
-//! ## ?Send Option
+//! ## ?Send option
 //!
-//! The returned future has a [`Send`] bound to make sure it can be sent between threads.
+//! The returned [`Future`] has a [`Send`] bound to make sure it can be sent between threads.
 //! If this is undesirable you can mark that the bound should be left out like so:
 //!
 //! ```rust
 //! # use async_recursion::async_recursion;
 //!
 //! #[async_recursion(?Send)]
-//! async fn example() {
+//! async fn returned_future_is_not_send() {
+//!     // ...
+//! }
+//! ```
+//!
+//! ## Sync option
+//!
+//! The returned [`Future`] doesn't have a [`Sync`] bound as it is usually not required.
+//! You can include a [`Sync`] bound as follows:
+//!
+//! ```rust
+//! # use async_recursion::async_recursion;
+//!
+//! #[async_recursion(Sync)]
+//! async fn returned_future_is_send_and_sync() {
 //!     // ...
 //! }
 //! ```
 //!
 //! In detail:
 //!
-//! - `#[async_recursion]` modifies your function to return a [`BoxFuture`], and
-//! - `#[async_recursion(?Send)]` modifies your function to return a [`LocalBoxFuture`].
 //!
-//! [`BoxFuture`]: https://docs.rs/futures/0.3.19/futures/future/type.BoxFuture.html
-//! [`LocalBoxFuture`]: https://docs.rs/futures/0.3.19/futures/future/type.LocalBoxFuture.html
+//! - `#[async_recursion]` modifies your function to return a boxed [`Future`] with a [`Send`] bound.
+//! - `#[async_recursion(?Send)]` modifies your function to return a boxed [`Future`] _without_ a [`Send`] bound.
+//! - `#[async_recursion(Sync)]` modifies your function to return a boxed [`Future`] with [`Send`] and [`Sync`] bounds.
 //!
 //! ### License
 //!

src/parse.rs

@@ -22,30 +22,74 @@ impl Parse for AsyncItem {
 
 pub struct RecursionArgs {
     pub send_bound: bool,
-}
-
-impl Default for RecursionArgs {
-    fn default() -> Self {
-        RecursionArgs { send_bound: true }
-    }
+    pub sync_bound: bool,
 }
 
 /// Custom keywords for parser
 mod kw {
     syn::custom_keyword!(Send);
+    syn::custom_keyword!(Sync);
 }
 
-impl Parse for RecursionArgs {
+#[derive(Debug, PartialEq, Eq)]
+enum Arg {
+    NotSend,
+    Sync,
+}
+
+impl std::fmt::Display for Arg {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NotSend => write!(f, "?Send"),
+            Self::Sync => write!(f, "Sync"),
+        }
+    }
+}
+
+impl Parse for Arg {
     fn parse(input: ParseStream) -> Result<Self> {
-        // Check for the `?Send` option
         if input.peek(Token![?]) {
             input.parse::<Question>()?;
             input.parse::<kw::Send>()?;
-            Ok(Self { send_bound: false })
-        } else if !input.is_empty() {
-            Err(input.error("expected `?Send` or empty"))
+            Ok(Arg::NotSend)
         } else {
-            Ok(Self::default())
+            input.parse::<kw::Sync>()?;
+            Ok(Arg::Sync)
         }
     }
 }
+
+impl Parse for RecursionArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut send_bound: bool = true;
+        let mut sync_bound: bool = false;
+
+        let args_parsed: Vec<Arg> =
+            syn::punctuated::Punctuated::<Arg, syn::Token![,]>::parse_terminated(input)
+                .map_err(|e| input.error(format!("failed to parse macro arguments: {e}")))?
+                .into_iter()
+                .collect();
+
+        // Avoid sloppy input
+        if args_parsed.len() > 2 {
+            return Err(Error::new(Span::call_site(), "received too many arguments"));
+        } else if args_parsed.len() == 2 && args_parsed[0] == args_parsed[1] {
+            return Err(Error::new(
+                Span::call_site(),
+                format!("received duplicate argument: `{}`", args_parsed[0]),
+            ));
+        }
+
+        for arg in args_parsed {
+            match arg {
+                Arg::NotSend => send_bound = false,
+                Arg::Sync => sync_bound = true,
+            }
+        }
+
+        Ok(Self {
+            send_bound,
+            sync_bound,
+        })
+    }
+}

tests/args_sync.rs

@@ -0,0 +1,11 @@
+use async_recursion::async_recursion;
+
+#[async_recursion(Sync)]
+async fn send_and_sync() {}
+
+fn assert_is_send_and_sync(_: impl Send + Sync) {}
+
+#[test]
+fn test_sync_argument() {
+    assert_is_send_and_sync(send_and_sync());
+}

tests/expand/args_not_send.expanded.rs

@@ -0,0 +1,5 @@
+use async_recursion::async_recursion;
+#[must_use]
+fn no_send_bound() -> ::core::pin::Pin<Box<dyn ::core::future::Future<Output = ()>>> {
+    Box::pin(async move {})
+}

tests/expand/args_not_send.rs

@@ -0,0 +1,4 @@
+use async_recursion::async_recursion;
+
+#[async_recursion(?Send)]
+async fn no_send_bound() {}

tests/expand/args_punctuated.expanded.rs

@@ -0,0 +1,25 @@
+use async_recursion::async_recursion;
+#[must_use]
+fn not_send_sync_1() -> ::core::pin::Pin<
+    Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Sync>,
+> {
+    Box::pin(async move {})
+}
+#[must_use]
+fn not_send_sync_2() -> ::core::pin::Pin<
+    Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Sync>,
+> {
+    Box::pin(async move {})
+}
+#[must_use]
+fn sync_not_send_1() -> ::core::pin::Pin<
+    Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Sync>,
+> {
+    Box::pin(async move {})
+}
+#[must_use]
+fn sync_not_send_2() -> ::core::pin::Pin<
+    Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Sync>,
+> {
+    Box::pin(async move {})
+}

tests/expand/args_punctuated.rs

@@ -0,0 +1,13 @@
+use async_recursion::async_recursion;
+
+#[async_recursion(?Send, Sync)]
+async fn not_send_sync_1() {}
+
+#[async_recursion(?Send,Sync)]
+async fn not_send_sync_2() {}
+
+#[async_recursion(Sync, ?Send)]
+async fn sync_not_send_1() {}
+
+#[async_recursion(Sync,?Send)]
+async fn sync_not_send_2() {}