feat: support default implement method

trait-variant/examples/variant.rs

@@ -20,12 +20,24 @@ pub trait LocalIntFactory {
     fn stream(&self) -> impl Iterator<Item = i32>;
     fn call(&self) -> u32;
     fn another_async(&self, input: Result<(), &str>) -> Self::MyFut<'_>;
+    fn default_stream(&self) -> impl Iterator<Item = i32> {
+        [1].into_iter()
+    }
+    async fn default_method(&self) -> u32 {
+        1
+    }
+    fn sync_default_method(&self) -> u32 {
+        1
+    }
 }
 
 #[allow(dead_code)]
 fn spawn_task(factory: impl IntFactory + 'static) {
     tokio::spawn(async move {
         let _int = factory.make(1, "foo").await;
+        let _default_int = factory.default_method().await;
+        let _default_stream = factory.default_stream();
+        let _sync_default_int = factory.sync_default_method();
     });
 }
 

trait-variant/src/variant.rs

@@ -150,12 +150,30 @@ fn transform_item(item: &TraitItem, bounds: &Vec<TypeParamBound>) -> TraitItem {
             ReturnType::Default => return item.clone(),
         }
     };
+
+    let default_impl = fn_item.default.as_ref().map(|default_impl| {
+        // only wrap async fn block with async move {}
+        if sig.asyncness.is_some() {
+            syn::parse2(quote! {
+                {
+                    async move {
+                        #default_impl
+                    }
+                }
+            })
+            .unwrap()
+        } else {
+            default_impl.clone()
+        }
+    });
+
     TraitItem::Fn(TraitItemFn {
         sig: Signature {
             asyncness: None,
             output: ReturnType::Type(arrow, Box::new(output)),
             ..sig.clone()
         },
+        default: default_impl,
         ..fn_item.clone()
     })
 }