Use inline bounds instead of where clauses

Author: djkoloski

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

trait_transformer/src/lib.rs

@@ -68,24 +68,8 @@ fn transform_trait(attrs: &Attrs, tr: &ItemTrait) -> TokenStream {
         .traits
         .iter()
         .map(|attr| {
-            let mut new_trait = ItemTrait {
-                attrs: Vec::new(),
-                ident: attr.subtrait_name.clone(),
-                items: Vec::new(),
-                ..tr.clone()
-            };
-            new_trait
-                .supertraits
-                .push(syn::TypeParamBound::Trait(TraitBound {
-                    paren_token: None,
-                    modifier: TraitBoundModifier::None,
-                    lifetimes: None,
-                    path: attr.subtrait.clone(),
-                }));
-            let where_clause = new_trait.generics.make_where_clause();
-
             let subtrait = &attr.subtrait;
-            for item in tr.items.iter() {
+            let fn_bounds = tr.items.iter().filter_map(|item| {
                 match item {
                     TraitItem::Fn(item_fn) => {
                         let is_async = item_fn.sig.asyncness.is_some();
@@ -98,20 +82,34 @@ fn transform_trait(attrs: &Attrs, tr: &ItemTrait) -> TokenStream {
 
                         if is_async || returns_impl_trait {
                             let name = &item_fn.sig.ident;
-                            where_clause
-                                .predicates
-                                .push(WherePredicate::Type(PredicateType {
-                                    lifetimes: None,
-                                    bounded_ty: Type::Verbatim(quote!(Self::#name())),
-                                    colon_token: Token![:](Span::call_site()),
-                                    bounds: parse_quote!(#subtrait),
-                                }));
+                            return Some(quote! { #name(): #subtrait });
                         }
                     }
                     _ => (),
                 }
+                None
+            });
+
+            let tr_ident = &tr.ident;
+            let supertrait = syn::TypeParamBound::Verbatim(quote! {
+                #tr_ident<#(#fn_bounds),*>
+            });
+
+            ItemTrait {
+                attrs: Vec::new(),
+                ident: attr.subtrait_name.clone(),
+                items: Vec::new(),
+                supertraits: Punctuated::from_iter(vec![
+                    supertrait,
+                    syn::TypeParamBound::Trait(TraitBound {
+                        paren_token: None,
+                        modifier: TraitBoundModifier::None,
+                        lifetimes: None,
+                        path: attr.subtrait.clone(),
+                    }),
+                ].into_iter()),
+                ..tr.clone()
             }
-            new_trait
         })
         .collect::<Vec<_>>();
 

trait_transformer_test/src/main.rs

@@ -6,6 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(async_fn_in_trait, return_position_impl_trait_in_trait, return_type_notation)]
+
 use trait_transformer::trait_transformer;
 
 #[trait_transformer(SendIntFactory: Send)]