Add Non-Send/Sync support

Author: benbrittain

README.md

@@ -97,6 +97,7 @@ can't be that badly broken.
 - :thumbsup: Default implementations provided by the trait;
 - :thumbsup: Elided lifetimes;
 - :thumbsup: Dyn-capable traits.
+- :thumbsup: Non-Send/Sync traits
 
 <br>
 

src/expand.rs

@@ -37,7 +37,7 @@ enum Context<'a> {
 
 type Supertraits = Punctuated<TypeParamBound, Token![+]>;
 
-pub fn expand(input: &mut Item) {
+pub fn expand(input: &mut Item, is_local: bool) {
     match input {
         Item::Trait(input) => {
             let context = Context::Trait {
@@ -49,10 +49,10 @@ pub fn expand(input: &mut Item) {
                 if let TraitItem::Method(method) = inner {
                     if method.sig.asyncness.is_some() {
                         if let Some(block) = &mut method.default {
-                            transform_block(context, &method.sig, block);
+                            transform_block(context, &method.sig, block, is_local);
                         }
                         let has_default = method.default.is_some();
-                        transform_sig(context, &mut method.sig, has_default);
+                        transform_sig(context, &mut method.sig, has_default, is_local);
                     }
                 }
             }
@@ -66,8 +66,8 @@ pub fn expand(input: &mut Item) {
             for inner in &mut input.items {
                 if let ImplItem::Method(method) = inner {
                     if method.sig.asyncness.is_some() {
-                        transform_block(context, &method.sig, &mut method.block);
-                        transform_sig(context, &mut method.sig, false);
+                        transform_block(context, &method.sig, &mut method.block, is_local);
+                        transform_sig(context, &mut method.sig, false, is_local);
                     }
                 }
             }
@@ -88,7 +88,7 @@ pub fn expand(input: &mut Item) {
 //         'life1: 'async_trait,
 //         T: 'async_trait,
 //         Self: Sync + 'async_trait;
-fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool) {
+fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool, is_local: bool) {
     sig.decl.fn_token.span = sig.asyncness.take().unwrap().span;
 
     let ret = match &sig.decl.output {
@@ -187,9 +187,15 @@ fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool) {
         }
     }
 
+    let bounds: Supertraits = if is_local {
+        parse_quote!(#lifetime)
+    } else {
+        parse_quote!(#lifetime + core::marker::Send)
+    };
+
     sig.decl.output = parse_quote! {
         -> core::pin::Pin<Box<
-            dyn core::future::Future<Output = #ret> + core::marker::Send + #lifetime
+            dyn core::future::Future<Output = #ret> + #bounds
         >>
     };
 }
@@ -204,7 +210,7 @@ fn transform_sig(context: Context, sig: &mut MethodSig, has_default: bool) {
 //         _self + x
 //     }
 //     Pin::from(Box::new(async_trait_method::<T, Self>(self, x)))
-fn transform_block(context: Context, sig: &MethodSig, block: &mut Block) {
+fn transform_block(context: Context, sig: &MethodSig, block: &mut Block, is_local: bool) {
     let inner = Ident::new(&format!("__{}", sig.ident), sig.ident.span());
     let args = sig
         .decl
@@ -271,9 +277,15 @@ fn transform_block(context: Context, sig: &MethodSig, block: &mut Block) {
                         _self: &#lifetime #mutability AsyncTrait
                     };
                     let (_, generics, _) = generics.split_for_impl();
-                    standalone.decl.generics.params.push(parse_quote! {
-                        AsyncTrait: ?Sized + #name #generics + core::marker::#bound
-                    });
+                    if is_local {
+                        standalone.decl.generics.params.push(parse_quote! {
+                            AsyncTrait: ?Sized + #name #generics
+                        });
+                    } else {
+                        standalone.decl.generics.params.push(parse_quote! {
+                            AsyncTrait: ?Sized + #name #generics + core::marker::#bound
+                        });
+                    }
                     types.push(Ident::new("Self", Span::call_site()));
                 }
                 Context::Impl { receiver, .. } => {

src/lib.rs

@@ -91,6 +91,11 @@
 //!
 //! # Supported features
 //!
+//! ## Non-Send/Sync Async traits
+//! Not all async traits need Send/Sync TypeBounds. To avoid having them placed
+//! on your generated methods, annotate your traits as `#[async_trait(local)]`
+//!
+//!
 //! It is the intention that all features of Rust traits should work nicely with
 //! #\[async_trait\], but the edge cases are numerous. Please file an issue if
 //! you see unexpected borrow checker errors, type errors, or warnings. There is
@@ -305,15 +310,19 @@ mod parse;
 mod receiver;
 
 use crate::expand::expand;
-use crate::parse::{Item, Nothing};
+use crate::parse::Item;
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::parse_macro_input;
 
+mod kw {
+    syn::custom_keyword!(local);
+}
+
 #[proc_macro_attribute]
 pub fn async_trait(args: TokenStream, input: TokenStream) -> TokenStream {
-    parse_macro_input!(args as Nothing);
+    let local = parse_macro_input!(args as Option<kw::local>).is_some();
     let mut item = parse_macro_input!(input as Item);
-    expand(&mut item);
+    expand(&mut item, local);
     TokenStream::from(quote!(#item))
 }

tests/test.rs

@@ -116,6 +116,21 @@ pub async fn test_object_safe_with_default() {
     object.f().await;
 }
 
+pub async fn test_object_no_send() {
+    #[async_trait(local)]
+    trait ObjectSafe: Sync {
+        async fn f(&self) {}
+    }
+
+    #[async_trait(local)]
+    impl ObjectSafe for Struct {
+        async fn f(&self) {}
+    }
+
+    let object = &Struct as &dyn ObjectSafe;
+    object.f().await;
+}
+
 // https://github.com/dtolnay/async-trait/issues/1
 mod issue1 {
     use async_trait::async_trait;