Add support for defaulted methods

Author: mendess

Diff for: trait-variant/examples/variant.rs

@@ -20,6 +20,9 @@ pub trait LocalIntFactory {
     fn stream(&self) -> impl Iterator<Item = i32>;
     fn call(&self) -> u32;
     fn another_async(&self, input: Result<(), &str>) -> Self::MyFut<'_>;
+    async fn defaulted(&self) -> i32 {
+        self.make(10, "10").await
+    }
 }
 
 #[allow(dead_code)]

Diff for: trait-variant/src/variant.rs

@@ -122,7 +122,7 @@ fn transform_item(item: &TraitItem, bounds: &Vec<TypeParamBound>) -> TraitItem {
     let TraitItem::Fn(fn_item @ TraitItemFn { sig, .. }) = item else {
         return item.clone();
     };
-    let (arrow, output) = if sig.asyncness.is_some() {
+    let (arrow, output, generics, default) = if sig.asyncness.is_some() {
         let orig = match &sig.output {
             ReturnType::Default => quote! { () },
             ReturnType::Type(_, ty) => quote! { #ty },
@@ -134,7 +134,24 @@ fn transform_item(item: &TraitItem, bounds: &Vec<TypeParamBound>) -> TraitItem {
                 .chain(bounds.iter().cloned())
                 .collect(),
         });
-        (syn::parse2(quote! { -> }).unwrap(), ty)
+        let mut generics = fn_item.sig.generics.clone();
+        if fn_item.default.is_some() {
+            if let Some(wh) = &mut generics.where_clause {
+                wh.predicates
+                    .push(syn::parse2(quote! { Self: Sync }).unwrap());
+            } else {
+                generics.where_clause = Some(syn::parse2(quote! { where Self: Sync }).unwrap())
+            }
+        }
+        (
+            syn::parse2(quote! { -> }).unwrap(),
+            ty,
+            generics,
+            fn_item
+                .default
+                .as_ref()
+                .map(|b| syn::parse2(quote! { { async move #b } }).unwrap()),
+        )
     } else {
         match &sig.output {
             ReturnType::Type(arrow, ty) => match &**ty {
@@ -143,7 +160,12 @@ fn transform_item(item: &TraitItem, bounds: &Vec<TypeParamBound>) -> TraitItem {
                         impl_token: it.impl_token,
                         bounds: it.bounds.iter().chain(bounds).cloned().collect(),
                     });
-                    (*arrow, ty)
+                    (
+                        *arrow,
+                        ty,
+                        fn_item.sig.generics.clone(),
+                        fn_item.default.clone(),
+                    )
                 }
                 _ => return item.clone(),
             },
@@ -154,8 +176,10 @@ fn transform_item(item: &TraitItem, bounds: &Vec<TypeParamBound>) -> TraitItem {
         sig: Signature {
             asyncness: None,
             output: ReturnType::Type(arrow, Box::new(output)),
+            generics,
             ..sig.clone()
         },
+        default,
         ..fn_item.clone()
     })
 }
@@ -164,8 +188,24 @@ fn mk_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));
+    // if there is a defaulted method, than that defaulted method has a bound of Self: Sync,
+    // which means the blanket impl must also require T: Sync
+    let self_is_sync = tr
+        .items
+        .iter()
+        .any(|item| {
+            matches!(
+                item,
+                TraitItem::Fn(TraitItemFn {
+                    default: Some(_),
+                    ..
+                })
+            )
+        })
+        .then(|| quote! { T: Sync })
+        .unwrap_or_default();
     quote! {
-        impl<T> #orig for T where T: #variant {
+        impl<T> #orig for T where T: #variant, #self_is_sync {
             #(#items)*
         }
     }