Add blanket impl

Author: tmandry

trait_transformer/examples/variant.rs

@@ -6,14 +6,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::future::Future;
+
 use trait_transformer::variant;
 
 #[variant(SendIntFactory: Send)]
 trait IntFactory {
-    async fn make(&self) -> i32;
-    // ..or..
+    const NAME: &'static str;
+
+    type MyFut<'a>: Future
+    where
+        Self: 'a;
+
+    async fn make(&self, x: u32, y: &str) -> i32;
     fn stream(&self) -> impl Iterator<Item = i32>;
     fn call(&self) -> u32;
+    fn another_async(&self, input: Result<(), &str>) -> Self::MyFut<'_>;
 }
 
 fn main() {}

trait_transformer/src/variant.rs

@@ -15,8 +15,9 @@ use syn::{
     parse_macro_input,
     punctuated::Punctuated,
     token::Plus,
-    Ident, ItemTrait, Result, ReturnType, Signature, Token, TraitBound, TraitItem, TraitItemFn,
-    Type, TypeImplTrait, TypeParamBound,
+    Error, FnArg, Generics, Ident, ItemTrait, Pat, PatType, Result, ReturnType, Signature, Token,
+    TraitBound, TraitItem, TraitItemConst, TraitItemFn, TraitItemType, Type, TypeImplTrait,
+    TypeParamBound,
 };
 
 struct Attrs {
@@ -56,9 +57,11 @@ pub fn variant(
     let item = parse_macro_input!(item as ItemTrait);
 
     let variant = make_variant(&attrs, &item);
+    let blanket_impl = make_blanket_impl(&attrs, &item);
     let output = quote! {
         #item
         #variant
+        #blanket_impl
     };
 
     output.into()
@@ -128,3 +131,65 @@ fn transform_item(item: &TraitItem, bounds: &Vec<TypeParamBound>) -> TraitItem {
         ..fn_item.clone()
     })
 }
+
+fn make_blanket_impl(attrs: &Attrs, tr: &ItemTrait) -> TokenStream {
+    let orig = &tr.ident;
+    let variant = &attrs.variant.name;
+    let items = tr.items.iter().map(|item| blanket_impl_item(item, variant));
+    quote! {
+        impl<T> #orig for T where T: #variant {
+            #(#items)*
+        }
+    }
+}
+
+fn blanket_impl_item(item: &TraitItem, variant: &Ident) -> TokenStream {
+    match item {
+        TraitItem::Const(TraitItemConst {
+            ident,
+            generics,
+            ty,
+            ..
+        }) => {
+            quote! {
+                const #ident #generics: #ty = <Self as #variant>::#ident;
+            }
+        }
+        TraitItem::Fn(TraitItemFn { sig, .. }) => {
+            let ident = &sig.ident;
+            let args = sig.inputs.iter().map(|arg| match arg {
+                FnArg::Receiver(_) => quote! { self },
+                FnArg::Typed(PatType { pat, .. }) => match &**pat {
+                    Pat::Ident(arg) => quote! { #arg },
+                    _ => Error::new_spanned(pat, "patterns are not supported in arguments")
+                        .to_compile_error(),
+                },
+            });
+            let maybe_await = if sig.asyncness.is_some() {
+                quote! { .await }
+            } else {
+                quote! {}
+            };
+            quote! {
+                #sig {
+                    <Self as #variant>::#ident(#(#args),*)#maybe_await
+                }
+            }
+        }
+        TraitItem::Type(TraitItemType {
+            ident,
+            generics:
+                Generics {
+                    params,
+                    where_clause,
+                    ..
+                },
+            ..
+        }) => {
+            quote! {
+                type #ident<#params> = <Self as #variant>::#ident<#params> #where_clause;
+            }
+        }
+        _ => Error::new_spanned(item, "unsupported item type").into_compile_error(),
+    }
+}