diff options
Diffstat (limited to 'macros/src')
| -rw-r--r-- | macros/src/dependency.rs | 81 | ||||
| -rw-r--r-- | macros/src/dependency_type.rs | 40 | ||||
| -rw-r--r-- | macros/src/injectable_impl.rs | 200 | ||||
| -rw-r--r-- | macros/src/lib.rs | 107 | ||||
| -rw-r--r-- | macros/src/named_attr_input.rs | 21 | ||||
| -rw-r--r-- | macros/src/util/item_impl.rs | 12 | ||||
| -rw-r--r-- | macros/src/util/mod.rs | 1 | ||||
| -rw-r--r-- | macros/src/util/syn_path.rs | 22 |
8 files changed, 304 insertions, 180 deletions
diff --git a/macros/src/dependency.rs b/macros/src/dependency.rs new file mode 100644 index 0000000..d20af90 --- /dev/null +++ b/macros/src/dependency.rs @@ -0,0 +1,81 @@ +use std::error::Error; + +use proc_macro2::Ident; +use syn::{parse2, FnArg, GenericArgument, LitStr, PathArguments, Type}; + +use crate::named_attr_input::NamedAttrInput; +use crate::util::syn_path::syn_path_to_string; + +pub struct Dependency +{ + pub interface: Type, + pub ptr: Ident, + pub name: Option<LitStr>, +} + +impl Dependency +{ + pub fn build(new_method_arg: &FnArg) -> Result<Self, Box<dyn Error>> + { + let typed_new_method_arg = match new_method_arg { + FnArg::Typed(typed_arg) => Ok(typed_arg), + FnArg::Receiver(_) => Err("Unexpected self argument in 'new' method"), + }?; + + let ptr_type_path = match typed_new_method_arg.ty.as_ref() { + Type::Path(arg_type_path) => Ok(arg_type_path), + Type::Reference(ref_type_path) => match ref_type_path.elem.as_ref() { + Type::Path(arg_type_path) => Ok(arg_type_path), + &_ => Err("Unexpected reference to non-path type"), + }, + &_ => Err("Expected a path or a reference type"), + }?; + + let ptr_path_segment = ptr_type_path.path.segments.last().map_or_else( + || Err("Expected pointer type path to have a last segment"), + Ok, + )?; + + let ptr = ptr_path_segment.ident.clone(); + + let ptr_path_generic_args = &match &ptr_path_segment.arguments { + PathArguments::AngleBracketed(generic_args) => Ok(generic_args), + &_ => Err("Expected pointer type to have a generic type argument"), + }? + .args; + + let interface = if let Some(GenericArgument::Type(interface)) = + ptr_path_generic_args.first() + { + Ok(interface.clone()) + } else { + Err("Expected pointer type to have a generic type argument") + }?; + + let arg_attrs = &typed_new_method_arg.attrs; + + let opt_named_attr = arg_attrs.iter().find(|attr| { + attr.path.get_ident().map_or_else( + || false, + |attr_ident| attr_ident.to_string().as_str() == "named", + ) || syn_path_to_string(&attr.path) == "syrette::named" + }); + + let opt_named_attr_tokens = opt_named_attr.map(|attr| &attr.tokens); + + let opt_named_attr_input = + if let Some(named_attr_tokens) = opt_named_attr_tokens { + Some(parse2::<NamedAttrInput>(named_attr_tokens.clone()).map_err( + |err| format!("Invalid input for 'named' attribute. {}", err), + )?) + } else { + None + }; + + Ok(Self { + interface, + ptr, + name: opt_named_attr_input.map(|named_attr_input| named_attr_input.name), + }) + } +} diff --git a/macros/src/dependency_type.rs b/macros/src/dependency_type.rs deleted file mode 100644 index 35f810e..0000000 --- a/macros/src/dependency_type.rs +++ /dev/null @@ -1,40 +0,0 @@ -use proc_macro2::Ident; -use syn::{GenericArgument, PathArguments, Type, TypePath}; - -pub struct DependencyType -{ - pub interface: Type, - pub ptr: Ident, -} - -impl DependencyType -{ - pub fn from_type_path(type_path: &TypePath) -> Option<Self> - { - // Assume the type path has a last segment. - let last_path_segment = type_path.path.segments.last().unwrap(); - - let ptr = &last_path_segment.ident; - - match &last_path_segment.arguments { - PathArguments::AngleBracketed(angle_bracketed_generic_args) => { - let generic_args = &angle_bracketed_generic_args.args; - - let opt_first_generic_arg = generic_args.first(); - - // Assume a first generic argument exists because TransientPtr, - // SingletonPtr and FactoryPtr requires one - let first_generic_arg = opt_first_generic_arg.as_ref().unwrap(); - - match first_generic_arg { - GenericArgument::Type(first_generic_arg_type) => Some(Self { - interface: first_generic_arg_type.clone(), - ptr: ptr.clone(), - }), - &_ => None, - } - } - &_ => None, - } - } -} diff --git a/macros/src/injectable_impl.rs b/macros/src/injectable_impl.rs index d74acb3..6edcab3 100644 --- a/macros/src/injectable_impl.rs +++ b/macros/src/injectable_impl.rs @@ -1,20 +1,20 @@ +use std::error::Error; + use quote::{format_ident, quote, ToTokens}; use syn::parse::{Parse, ParseStream}; use syn::Generics; -use syn::{ - parse_str, punctuated::Punctuated, token::Comma, ExprMethodCall, FnArg, ItemImpl, - Path, Type, TypePath, -}; +use syn::{parse_str, ExprMethodCall, FnArg, ItemImpl, Type}; -use crate::dependency_type::DependencyType; -use crate::util::item_impl::find_impl_method_by_name; +use crate::dependency::Dependency; +use crate::util::item_impl::find_impl_method_by_name_mut; +use crate::util::syn_path::syn_path_to_string; const DI_CONTAINER_VAR_NAME: &str = "di_container"; const DEPENDENCY_HISTORY_VAR_NAME: &str = "dependency_history"; pub struct InjectableImpl { - pub dependency_types: Vec<DependencyType>, + pub dependencies: Vec<Dependency>, pub self_type: Type, pub generics: Generics, pub original_impl: ItemImpl, @@ -24,13 +24,13 @@ impl Parse for InjectableImpl { fn parse(input: ParseStream) -> syn::Result<Self> { - let impl_parsed_input = input.parse::<ItemImpl>()?; + let mut impl_parsed_input = input.parse::<ItemImpl>()?; - let dependency_types = Self::get_dependency_types(&impl_parsed_input) + let dependencies = Self::build_dependencies(&mut impl_parsed_input) .map_err(|err| input.error(err))?; Ok(Self { - dependency_types, + dependencies, self_type: impl_parsed_input.self_ty.as_ref().clone(), generics: impl_parsed_input.generics.clone(), original_impl: impl_parsed_input, @@ -43,7 +43,7 @@ impl InjectableImpl pub fn expand(&self, no_doc_hidden: bool) -> proc_macro2::TokenStream { let Self { - dependency_types, + dependencies, self_type, generics, original_impl, @@ -52,7 +52,7 @@ impl InjectableImpl let di_container_var = format_ident!("{}", DI_CONTAINER_VAR_NAME); let dependency_history_var = format_ident!("{}", DEPENDENCY_HISTORY_VAR_NAME); - let get_dep_method_calls = Self::create_get_dep_method_calls(dependency_types); + let get_dep_method_calls = Self::create_get_dep_method_calls(dependencies); let maybe_doc_hidden = if no_doc_hidden { quote! {} @@ -111,46 +111,38 @@ impl InjectableImpl } fn create_get_dep_method_calls( - dependency_types: &[DependencyType], + dependencies: &[Dependency], ) -> Vec<proc_macro2::TokenStream> { - dependency_types + dependencies .iter() - .filter_map(|dep_type| match &dep_type.interface { - Type::TraitObject(dep_type_trait) => { - let method_call = parse_str::<ExprMethodCall>( - format!( - "{}.get_bound::<{}>({}.clone())", - DI_CONTAINER_VAR_NAME, - dep_type_trait.to_token_stream(), - DEPENDENCY_HISTORY_VAR_NAME - ) - .as_str(), - ) - .ok()?; - - Some((method_call, dep_type)) - - /* - */ - } - Type::Path(dep_type_path) => { - let dep_type_path_str = Self::path_to_string(&dep_type_path.path); - - let method_call: ExprMethodCall = parse_str( - format!( - "{}.get_bound::<{}>({}.clone())", - DI_CONTAINER_VAR_NAME, - dep_type_path_str, - DEPENDENCY_HISTORY_VAR_NAME + .filter_map(|dependency| { + let dep_interface_str = match &dependency.interface { + Type::TraitObject(interface_trait) => { + Some(interface_trait.to_token_stream().to_string()) + } + Type::Path(path_interface) => { + Some(syn_path_to_string(&path_interface.path)) + } + &_ => None, + }?; + + let method_call = parse_str::<ExprMethodCall>( + format!( + "{}.get_bound::<{}>({}.clone(), {})", + DI_CONTAINER_VAR_NAME, + dep_interface_str, + DEPENDENCY_HISTORY_VAR_NAME, + dependency.name.as_ref().map_or_else( + || "None".to_string(), + |name| format!("Some(\"{}\")", name.value()) ) - .as_str(), ) - .ok()?; + .as_str(), + ) + .ok()?; - Some((method_call, dep_type)) - } - &_ => None, + Some((method_call, dependency)) }) .map(|(method_call, dep_type)| { let ptr_name = dep_type.ptr.to_string(); @@ -168,95 +160,47 @@ impl InjectableImpl .collect() } - #[allow(clippy::match_wildcard_for_single_variants)] - fn get_has_fn_args_self(fn_args: &Punctuated<FnArg, Comma>) -> bool - { - fn_args.iter().any(|arg| match arg { - FnArg::Receiver(_) => true, - &_ => false, - }) - } - - fn get_fn_arg_type_paths(fn_args: &Punctuated<FnArg, Comma>) -> Vec<&TypePath> - { - fn_args - .iter() - .filter_map(|arg| match arg { - FnArg::Typed(typed_fn_arg) => match typed_fn_arg.ty.as_ref() { - Type::Path(arg_type_path) => Some(arg_type_path), - Type::Reference(ref_type_path) => match ref_type_path.elem.as_ref() { - Type::Path(arg_type_path) => Some(arg_type_path), - &_ => None, - }, - &_ => None, - }, - FnArg::Receiver(_receiver_fn_arg) => None, - }) - .collect() - } - - fn path_to_string(path: &Path) -> String - { - path.segments - .pairs() - .fold(String::new(), |mut acc, segment_pair| { - let segment_ident = &segment_pair.value().ident; - - acc.push_str(segment_ident.to_string().as_str()); - - let opt_colon_two = segment_pair.punct(); - - match opt_colon_two { - Some(colon_two) => { - acc.push_str(colon_two.to_token_stream().to_string().as_str()); - } - None => {} - } - - acc - }) - } - - fn is_type_path_ptr(type_path: &TypePath) -> bool + fn build_dependencies( + item_impl: &mut ItemImpl, + ) -> Result<Vec<Dependency>, Box<dyn Error>> { - let arg_type_path_string = Self::path_to_string(&type_path.path); - - arg_type_path_string == "TransientPtr" - || arg_type_path_string == "ptr::TransientPtr" - || arg_type_path_string == "syrrete::ptr::TransientPtr" - || arg_type_path_string == "SingletonPtr" - || arg_type_path_string == "ptr::SingletonPtr" - || arg_type_path_string == "syrrete::ptr::SingletonPtr" - || arg_type_path_string == "FactoryPtr" - || arg_type_path_string == "ptr::FactoryPtr" - || arg_type_path_string == "syrrete::ptr::FactoryPtr" - } - - fn get_dependency_types( - item_impl: &ItemImpl, - ) -> Result<Vec<DependencyType>, &'static str> - { - let new_method_impl_item = find_impl_method_by_name(item_impl, "new") + let new_method_impl_item = find_impl_method_by_name_mut(item_impl, "new") .map_or_else(|| Err("Missing a 'new' method"), Ok)?; - let new_method_args = &new_method_impl_item.sig.inputs; + let new_method_args = &mut new_method_impl_item.sig.inputs; + + let dependencies: Result<Vec<_>, _> = + new_method_args.iter().map(Dependency::build).collect(); + + for arg in new_method_args { + let typed_arg = if let FnArg::Typed(typed_arg) = arg { + typed_arg + } else { + continue; + }; + + let attrs_to_remove: Vec<_> = typed_arg + .attrs + .iter() + .enumerate() + .filter_map(|(index, attr)| { + if syn_path_to_string(&attr.path).as_str() == "syrette::named" { + return Some(index); + } - if Self::get_has_fn_args_self(new_method_args) { - return Err("Unexpected self argument in 'new' method"); - } + if attr.path.get_ident()?.to_string().as_str() == "named" { + return Some(index); + } - let new_method_arg_type_paths = Self::get_fn_arg_type_paths(new_method_args); + None + }) + .collect(); - if new_method_arg_type_paths - .iter() - .any(|arg_type_path| !Self::is_type_path_ptr(arg_type_path)) - { - return Err("All argument types in 'new' method must ptr types"); + for attr_index in attrs_to_remove { + typed_arg.attrs.remove(attr_index); + } } - Ok(new_method_arg_type_paths - .iter() - .filter_map(|arg_type_path| DependencyType::from_type_path(arg_type_path)) - .collect()) + dependencies } } diff --git a/macros/src/lib.rs b/macros/src/lib.rs index 9b97be6..c7157c8 100644 --- a/macros/src/lib.rs +++ b/macros/src/lib.rs @@ -9,11 +9,12 @@ use quote::quote; use syn::{parse, parse_macro_input}; mod declare_interface_args; -mod dependency_type; +mod dependency; mod factory_type_alias; mod injectable_impl; mod injectable_macro_args; mod libs; +mod named_attr_input; mod util; use declare_interface_args::DeclareInterfaceArgs; @@ -38,15 +39,60 @@ use libs::intertrait_macros::gen_caster::generate_caster; /// declare the interface with the [`declare_interface!`] macro or use /// the [`di_container_bind`] macro to create a DI container binding. /// -/// # Example +/// # Attributes +/// Attributes specific to impls with this attribute macro. +/// +/// ### Named +/// Used inside the `new` method before a dependency argument. Declares the name of the +/// dependency. Should be given the name quoted inside parenthesis. +/// +/// The [`macro@named`] ghost attribute macro can be used for intellisense and +/// autocompletion for this attribute. +/// +/// For example: /// ``` -/// use syrette::injectable; +/// # use syrette::ptr::TransientPtr; +/// # use syrette::injectable; +/// # +/// # trait IArmor {} +/// # +/// # trait IKnight {} +/// # +/// # struct Knight +/// # { +/// # tough_armor: TransientPtr<dyn IArmor>, +/// # light_armor: TransientPtr<dyn IArmor>, +/// # } +/// # +/// #[injectable(IKnight)] +/// impl Knight +/// { +/// pub fn new( +/// #[named("tough")] +/// tough_armor: TransientPtr<dyn IArmor>, /// -/// struct PasswordManager {} +/// #[named("light")] +/// light_armor: TransientPtr<dyn IArmor> +/// ) -> Self +/// { +/// Self { tough_armor, light_armor } +/// } +/// } +/// # +/// # impl IKnight for Knight {} +/// ``` /// +/// # Example +/// ``` +/// # use syrette::injectable; +/// # +/// # struct PasswordManager {} +/// # /// #[injectable] -/// impl PasswordManager { -/// pub fn new() -> Self { +/// impl PasswordManager +/// { +/// pub fn new() -> Self +/// { /// Self {} /// } /// } @@ -191,3 +237,52 @@ pub fn declare_interface(input: TokenStream) -> TokenStream generate_caster(&implementation, &interface).into() } + +/// Declares the name of a dependency. +/// +/// This macro attribute doesn't actually do anything. It only exists for the +/// convenience of having intellisense and autocompletion. +/// You might as well just use `named` if you don't care about that. +/// +/// Only means something inside a `new` method inside a impl with +/// the [`macro@injectable`] macro attribute. +/// +/// # Examples +/// ``` +/// # use syrette::ptr::TransientPtr; +/// # use syrette::injectable; +/// # +/// # trait INinja {} +/// # trait IWeapon {} +/// # +/// # struct Ninja +/// # { +/// # strong_weapon: TransientPtr<dyn IWeapon>, +/// # weak_weapon: TransientPtr<dyn IWeapon>, +/// # } +/// # +/// #[injectable(INinja)] +/// impl Ninja +/// { +/// pub fn new( +/// #[syrette::named("strong")] +/// strong_weapon: TransientPtr<dyn IWeapon>, +/// +/// #[syrette::named("weak")] +/// weak_weapon: TransientPtr<dyn IWeapon>, +/// ) -> Self +/// { +/// Self { +/// strong_weapon, +/// weak_weapon, +/// } +/// } +/// } +/// # +/// # impl INinja for Ninja {} +/// ``` +#[proc_macro_attribute] +pub fn named(_: TokenStream, _: TokenStream) -> TokenStream +{ + TokenStream::new() +} diff --git a/macros/src/named_attr_input.rs b/macros/src/named_attr_input.rs new file mode 100644 index 0000000..5f7123c --- /dev/null +++ b/macros/src/named_attr_input.rs @@ -0,0 +1,21 @@ +use syn::parse::Parse; +use syn::{parenthesized, LitStr}; + +pub struct NamedAttrInput +{ + pub name: LitStr, +} + +impl Parse for NamedAttrInput +{ + fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> + { + let content; + + parenthesized!(content in input); + + Ok(Self { + name: content.parse()?, + }) + } +} diff --git a/macros/src/util/item_impl.rs b/macros/src/util/item_impl.rs index 271ae2f..4bd7492 100644 --- a/macros/src/util/item_impl.rs +++ b/macros/src/util/item_impl.rs @@ -1,13 +1,13 @@ use syn::{ImplItem, ImplItemMethod, ItemImpl}; -pub fn find_impl_method_by_name<'item_impl>( - item_impl: &'item_impl ItemImpl, +pub fn find_impl_method_by_name_mut<'item_impl>( + item_impl: &'item_impl mut ItemImpl, method_name: &'static str, -) -> Option<&'item_impl ImplItemMethod> +) -> Option<&'item_impl mut ImplItemMethod> { - let impl_items = &item_impl.items; + let impl_items = &mut item_impl.items; - impl_items.iter().find_map(|impl_item| match impl_item { + impl_items.iter_mut().find_map(|impl_item| match impl_item { ImplItem::Method(method_item) => { if method_item.sig.ident == method_name { Some(method_item) @@ -15,6 +15,6 @@ pub fn find_impl_method_by_name<'item_impl>( None } } - &_ => None, + &mut _ => None, }) } diff --git a/macros/src/util/mod.rs b/macros/src/util/mod.rs index fc7b2c6..4f2a594 100644 --- a/macros/src/util/mod.rs +++ b/macros/src/util/mod.rs @@ -1,2 +1,3 @@ pub mod item_impl; pub mod iterator_ext; +pub mod syn_path; diff --git a/macros/src/util/syn_path.rs b/macros/src/util/syn_path.rs new file mode 100644 index 0000000..15653bf --- /dev/null +++ b/macros/src/util/syn_path.rs @@ -0,0 +1,22 @@ +#![allow(clippy::module_name_repetitions)] +use quote::ToTokens; +use syn::punctuated::Pair; + +pub fn syn_path_to_string(path: &syn::Path) -> String +{ + path.segments + .pairs() + .map(Pair::into_tuple) + .map(|(segment, opt_punct)| { + let segment_ident = &segment.ident; + + format!( + "{}{}", + segment_ident, + opt_punct.map_or_else(String::new, |punct| punct + .to_token_stream() + .to_string()) + ) + }) + .collect() +} |