feat(macros): support using #[dynify] on remote items (#17)

Author: loichyan

.github/codecov.yml

@@ -8,3 +8,4 @@ coverage:
       default:
         enabled: true
         threshold: 1%
+    patch: false

CHANGELOG.md

@@ -37,6 +37,12 @@ follows <https://www.conventionalcommits.org/en/v1.0.0/> to track changes.
 
 ## [Unreleased]
 
+### Added
+
+- Support using `#[dynify]` on remote items ([#17])
+
+[#17]: https://github.com/loichyan/dynify/pull/17
+
 ## [0.1.1] - 2025-08-28
 
 The major update since the previous release is the introduction of the

macros/src/dynify.rs

@@ -1,39 +1,52 @@
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, ToTokens};
-use syn::{parse_quote_spanned, FnArg, Ident, Lifetime, Result, ReturnType, Token, Type};
+use syn::parse::ParseStream;
+use syn::{
+    parse_quote, parse_quote_spanned, FnArg, Ident, Lifetime, LitStr, Result, ReturnType, Token,
+    Type,
+};
 
 use crate::lifetime::TraitContext;
 use crate::utils::*;
 
 pub fn expand(attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
-    let rename = syn::parse2::<Option<Ident>>(attr)?;
+    let opts = syn::parse2::<Options>(attr)?;
     let input_item = syn::parse2::<syn::Item>(input.clone())?;
+
+    let is_remote = opts.remote.is_some();
     let output = match input_item {
-        syn::Item::Trait(t) => expand_trait(rename, t)?,
-        syn::Item::Fn(f) => expand_fn(rename, f)?,
+        syn::Item::Trait(t) => expand_trait(opts, t)?,
+        syn::Item::Fn(f) => expand_fn(opts, f)?,
         item => {
             return Err(syn::Error::new_spanned(
                 &item,
                 "expected a `fn` or `trait` item",
             ))
         },
     };
-    Ok(quote!(
-        #[allow(async_fn_in_trait)]
-        #input
-        #output
-    ))
-}
 
-fn expand_trait(rename: Option<Ident>, mut dyn_trait: syn::ItemTrait) -> Result<TokenStream> {
-    let dyn_trait_name = rename.unwrap_or_else(|| format_ident!("Dyn{}", dyn_trait.ident));
-    let input_trait_name = std::mem::replace(&mut dyn_trait.ident, dyn_trait_name);
-    let dyn_trait_name = &dyn_trait.ident;
+    let input = (!is_remote).then_some(input);
+    Ok(quote!(#input #output))
+}
 
-    let impl_target = format_ident!("{}Implementor", input_trait_name);
-    let mut trait_impl_items = TokenStream::new();
+fn expand_trait(opts: Options, mut dyn_trait: syn::ItemTrait) -> Result<TokenStream> {
+    let target_trait = if let Some(remote) = opts.remote {
+        remote
+    } else {
+        let dyn_trait_name = opts
+            .rename
+            .unwrap_or_else(|| format_ident!("Dyn{}", dyn_trait.ident));
+        let target_trait_name = std::mem::replace(&mut dyn_trait.ident, dyn_trait_name);
+        parse_quote!(#target_trait_name)
+    };
 
+    let impl_target = {
+        let target_trait_name = &target_trait.segments.last().unwrap().ident;
+        format_ident!("{}Implementor", target_trait_name)
+    };
     let (_, ty_generics, where_clause) = dyn_trait.generics.split_for_impl();
+
+    let mut trait_impl_items = TokenStream::new();
     for item in dyn_trait.items.iter_mut() {
         let impl_item = match item {
             syn::TraitItem::Const(syn::TraitItemConst {
@@ -71,12 +84,12 @@ fn expand_trait(rename: Option<Ident>, mut dyn_trait: syn::ItemTrait) -> Result<
                 // TODO: support nested `#[dynify]`
                 let attrs_outer = attrs.outer();
                 let attrs_inner = attrs.inner();
-                let target = quote_with(|tokens| {
+                let target_fn = quote_with(|tokens| {
                     impl_target.to_tokens(tokens);
                     NewToken![::].to_tokens(tokens);
                     sig.ident.to_tokens(tokens);
                 });
-                let impl_body = quote_transformed_body(transformed, &target, sig);
+                let impl_body = quote_transformed_body(transformed, &target_fn, sig);
                 quote!(#(#attrs_outer)* #sig { #(#attrs_inner)* #impl_body })
             },
             _ => continue,
@@ -85,33 +98,42 @@ fn expand_trait(rename: Option<Ident>, mut dyn_trait: syn::ItemTrait) -> Result<
     }
 
     let impl_generics = quote_impl_generics(&dyn_trait.generics);
+    let dyn_trait_name = &dyn_trait.ident;
+
     Ok(quote!(
         #[allow(async_fn_in_trait)]
         #[allow(clippy::type_complexity)]
         #dyn_trait
 
         #[allow(clippy::type_complexity)]
-        impl<#impl_generics #impl_target: #input_trait_name #ty_generics>
+        impl<#impl_generics #impl_target: #target_trait #ty_generics>
         #dyn_trait_name #ty_generics for #impl_target
         #where_clause { #trait_impl_items }
     ))
 }
 
-fn expand_fn(rename: Option<Ident>, mut dyn_fn: syn::ItemFn) -> Result<TokenStream> {
+fn expand_fn(opts: Options, mut dyn_fn: syn::ItemFn) -> Result<TokenStream> {
     let syn::ItemFn {
         vis,
         sig,
         attrs,
         block: _,
     } = &mut dyn_fn;
 
-    let dyn_fn_name = rename.unwrap_or_else(|| format_ident!("dyn_{}", sig.ident));
-    let input_fn_name = std::mem::replace(&mut sig.ident, dyn_fn_name);
+    let target_fn = if let Some(remote) = opts.remote {
+        remote
+    } else {
+        let dyn_fn_name = opts
+            .rename
+            .unwrap_or_else(|| format_ident!("dyn_{}", sig.ident));
+        let target_fn_name = std::mem::replace(&mut sig.ident, dyn_fn_name);
+        parse_quote!(#target_fn_name)
+    };
 
     let transformed = transform_fn(None, sig, true)?;
     let attrs_outer = attrs.outer();
     let attrs_inner = attrs.inner();
-    let impl_body = quote_transformed_body(transformed, &input_fn_name, sig);
+    let impl_body = quote_transformed_body(transformed, &target_fn, sig);
     Ok(quote!(#(#attrs_outer)* #vis #sig { #(#attrs_inner)* #impl_body }))
 }
 
@@ -259,6 +281,39 @@ fn get_impl_type(ty: &ReturnType) -> Option<(Token![->], &syn::TypeImplTrait)> {
         .and_then(|(r, ty)| as_variant!(&**ty, Type::ImplTrait).map(|ty| (*r, ty)))
 }
 
+struct Options {
+    rename: Option<Ident>,
+    remote: Option<syn::Path>,
+}
+
+impl syn::parse::Parse for Options {
+    fn parse(input: ParseStream) -> Result<Options> {
+        syn::custom_keyword!(remote);
+
+        let mut attrs = Options {
+            rename: None,
+            remote: None,
+        };
+
+        // The syntax for specifying arbitrary tokens as the value of an option
+        // follows those used in [serde](https://github.com/serde-rs/serde).
+        if input.peek2(Token![=]) {
+            let remote_token = input.parse::<remote>()?;
+            let _eq_token = input.parse::<Token![=]>()?;
+            let remote = input.parse::<LitStr>()?.parse::<syn::Path>()?;
+            if remote.segments.is_empty() {
+                return Err(syn::Error::new(remote_token.span, "invalid remote type"));
+            }
+            attrs.remote = Some(remote);
+        } else if !input.is_empty() {
+            attrs.rename = Some(input.parse()?);
+        }
+        input.parse::<syn::parse::Nothing>()?;
+
+        Ok(attrs)
+    }
+}
+
 #[cfg(test)]
 #[path = "dynify_tests.rs"]
 mod tests;

macros/src/dynify_tests.rs

@@ -96,6 +96,15 @@ define_macro_tests!(
         quote!(my_dyn_test),
         quote!(async fn test(_arg1: &str) -> String { todo!() }),
     )]
+    // == Remote items == //
+    #[case::remote_trait(
+        quote!(remote = "dynify::r#priv::TestRemoteTrait"),
+        quote!(trait DynTestRemoteTrait { async fn test(&self, arg: &str) -> usize; }),
+    )]
+    #[case::remote_fn(
+        quote!(remote = "dynify::r#priv::test_remote_fn"),
+        quote!(async fn dyn_test_remote_fn(_arg1: &str) -> usize {}),
+    )]
     fn ui(#[case] test_name: &str, #[case] attr: TokenStream, #[case] input: TokenStream) {
         let output = expand(attr, input).unwrap();
         // Append `fn main() {}` so that they can pass compile tests

macros/src/dynify_tests/fn_renamed.rs

@@ -1,5 +1,4 @@
 /* This file is @generated for testing purpose */
-#[allow(async_fn_in_trait)]
 async fn test(_arg1: &str) -> String {
     todo!()
 }

macros/src/dynify_tests/fn_returning_async.rs

@@ -1,5 +1,4 @@
 /* This file is @generated for testing purpose */
-#[allow(async_fn_in_trait)]
 async fn test(_arg1: &str) -> String {
     todo!()
 }

macros/src/dynify_tests/fn_returning_impl.rs

@@ -1,5 +1,4 @@
 /* This file is @generated for testing purpose */
-#[allow(async_fn_in_trait)]
 fn test() -> impl core::any::Any {
     todo!()
 }

macros/src/dynify_tests/fn_with_vis.rs

@@ -1,5 +1,4 @@
 /* This file is @generated for testing purpose */
-#[allow(async_fn_in_trait)]
 pub(crate) fn test() -> impl core::any::Any {
     todo!()
 }

macros/src/dynify_tests/remote_fn.rs

@@ -0,0 +1,13 @@
+/* This file is @generated for testing purpose */
+fn dyn_test_remote_fn<'_arg1, 'dynify>(
+    _arg1: &'_arg1 str,
+) -> ::dynify::r#priv::Fn<
+    (&'_arg1 str,),
+    dyn 'dynify + ::core::future::Future<Output = usize>,
+>
+where
+    '_arg1: 'dynify,
+{
+    ::dynify::__from_fn!([] dynify::r#priv::test_remote_fn, _arg1,)
+}
+fn main() {}

macros/src/dynify_tests/remote_trait.rs

@@ -0,0 +1,35 @@
+/* This file is @generated for testing purpose */
+#[allow(async_fn_in_trait)]
+#[allow(clippy::type_complexity)]
+trait DynTestRemoteTrait {
+    fn test<'this, 'arg, 'dynify>(
+        &'this self,
+        arg: &'arg str,
+    ) -> ::dynify::r#priv::Fn<
+        (::dynify::r#priv::RefSelf, &'arg str),
+        dyn 'dynify + ::core::future::Future<Output = usize>,
+    >
+    where
+        'this: 'dynify,
+        'arg: 'dynify,
+        Self: 'dynify;
+}
+#[allow(clippy::type_complexity)]
+impl<TestRemoteTraitImplementor: dynify::r#priv::TestRemoteTrait> DynTestRemoteTrait
+for TestRemoteTraitImplementor {
+    fn test<'this, 'arg, 'dynify>(
+        &'this self,
+        arg: &'arg str,
+    ) -> ::dynify::r#priv::Fn<
+        (::dynify::r#priv::RefSelf, &'arg str),
+        dyn 'dynify + ::core::future::Future<Output = usize>,
+    >
+    where
+        'this: 'dynify,
+        'arg: 'dynify,
+        Self: 'dynify,
+    {
+        ::dynify::__from_fn!([self] TestRemoteTraitImplementor::test, self, arg,)
+    }
+}
+fn main() {}