feat!: Implement support for generic params

macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "async-generic"
-version = "1.1.2"
+version = "2.0.0"
 description = "Write code that can be both async and synchronous without duplicating it."
 authors = ["Eric Scouten <[email protected]>"]
 license = "MIT OR Apache-2.0"

macros/src/async_generic_target/fn/kind.rs

@@ -0,0 +1,109 @@
+use proc_macro2::{Ident, Span};
+use syn::{punctuated::Punctuated, Attribute, FnArg, Generics, ReturnType, Token};
+
+use crate::AsyncSignature;
+
+pub struct Sync;
+
+pub struct Async(pub(super) Option<AsyncSignature>);
+
+pub trait Kind {
+    fn transform_constness(constness: Option<Token![const]>) -> Option<Token![const]> {
+        constness
+    }
+
+    fn asyncness() -> Option<Token![async]>;
+
+    fn extend_attrs(&mut self, attrs: Vec<Attribute>) -> Vec<Attribute> {
+        attrs
+    }
+
+    fn transform_ident(ident: Ident) -> Ident {
+        ident
+    }
+
+    fn transform_generics(&mut self, generics: Generics) -> Generics {
+        generics
+    }
+
+    fn transform_inputs(
+        &mut self,
+        inputs: Punctuated<FnArg, Token![,]>,
+    ) -> Punctuated<FnArg, Token![,]> {
+        inputs
+    }
+
+    fn transform_output(&mut self, output: ReturnType) -> ReturnType {
+        output
+    }
+}
+
+impl Kind for Sync {
+    fn asyncness() -> Option<Token![async]> {
+        None
+    }
+}
+
+impl Kind for Async {
+    fn transform_constness(_constness: Option<Token!(const)>) -> Option<Token!(const)> {
+        None // TODO: retutn `constness` when `const async fn` is stabilized
+    }
+
+    fn asyncness() -> Option<Token![async]> {
+        Some(Token![async](Span::call_site()))
+    }
+
+    fn extend_attrs(&mut self, mut attrs: Vec<Attribute>) -> Vec<Attribute> {
+        if let Some(alt_attrs) = self
+            .0
+            .as_mut()
+            .map(|AsyncSignature { attributes, .. }| std::mem::take(attributes))
+        {
+            attrs.extend(alt_attrs);
+        }
+        attrs
+    }
+
+    fn transform_ident(ident: Ident) -> Ident {
+        Ident::new(&format!("{ident}_async"), ident.span())
+    }
+
+    fn transform_generics(&mut self, generics: Generics) -> Generics {
+        if let Some(alt_generics) = self
+            .0
+            .as_mut()
+            .map(|AsyncSignature { generics, .. }| std::mem::take(generics))
+        {
+            alt_generics
+        } else {
+            generics
+        }
+    }
+
+    fn transform_inputs(
+        &mut self,
+        inputs: Punctuated<FnArg, Token!(,)>,
+    ) -> Punctuated<FnArg, Token!(,)> {
+        if let Some(alt_inputs) = self
+            .0
+            .as_mut()
+            .map(|AsyncSignature { inputs, .. }| std::mem::take(inputs))
+        {
+            alt_inputs
+        } else {
+            inputs
+        }
+    }
+
+    fn transform_output(&mut self, output: ReturnType) -> ReturnType {
+        if let Some(alt_output) = self.0.as_mut().map(|AsyncSignature { output, .. }| {
+            let mut default = ReturnType::Default;
+            std::mem::swap(output, &mut default);
+            default
+        }) {
+            alt_output
+        } else {
+            output
+        }
+    }
+}