From c48271aef7e6b0819c497f302127c161845a83d7 Mon Sep 17 00:00:00 2001 From: HampusM Date: Sat, 18 Mar 2023 17:14:42 +0100 Subject: refactor: rewrite the mock macro as a procedural macro --- macros/src/expectation.rs | 376 ++++++++++++++++++++++++++++++++++++++++++++++ macros/src/lib.rs | 54 +++++++ macros/src/mock.rs | 313 ++++++++++++++++++++++++++++++++++++++ macros/src/mock_input.rs | 51 +++++++ macros/src/syn_ext.rs | 372 +++++++++++++++++++++++++++++++++++++++++++++ macros/src/util.rs | 22 +++ 6 files changed, 1188 insertions(+) create mode 100644 macros/src/expectation.rs create mode 100644 macros/src/lib.rs create mode 100644 macros/src/mock.rs create mode 100644 macros/src/mock_input.rs create mode 100644 macros/src/syn_ext.rs create mode 100644 macros/src/util.rs (limited to 'macros/src') diff --git a/macros/src/expectation.rs b/macros/src/expectation.rs new file mode 100644 index 0000000..ff3d192 --- /dev/null +++ b/macros/src/expectation.rs @@ -0,0 +1,376 @@ +use proc_macro2::{Ident, TokenStream}; +use quote::{format_ident, quote, ToTokens}; +use syn::punctuated::Punctuated; +use syn::token::Brace; +use syn::{ + AngleBracketedGenericArguments, + Attribute, + BareFnArg, + Field, + Fields, + FieldsNamed, + FnArg, + GenericArgument, + GenericParam, + Generics, + ItemStruct, + Lifetime, + Path, + PathSegment, + Receiver, + ReturnType, + Token, + TraitItemMethod, + Type, + TypeBareFn, + TypePath, + TypeReference, + Visibility, +}; + +use crate::syn_ext::{ + AngleBracketedGenericArgumentsExt, + AttributeExt, + AttributeStyle, + BareFnArgExt, + GenericsExt, + IsMut, + LifetimeExt, + PathExt, + PathSegmentExt, + TypeBareFnExt, + TypePathExt, + TypeReferenceExt, + VisibilityExt, + WithColons, + WithLeadingColons, +}; +use crate::util::{create_path, create_unit_type_tuple}; + +pub struct Expectation +{ + ident: Ident, + generics: Generics, + receiver: Option, + mock: Ident, + arg_types: Vec, + return_type: ReturnType, + phantom_fields: Vec, +} + +impl Expectation +{ + pub fn new(mock: &Ident, item_method: &TraitItemMethod) -> Self + { + let ident = create_expectation_ident(mock, &item_method.sig.ident); + + let phantom_fields = + Self::create_phantom_fields(&item_method.sig.generics.params); + + let receiver = + item_method + .sig + .inputs + .first() + .and_then(|first_arg| match first_arg { + FnArg::Receiver(receiver) => Some(receiver.clone()), + FnArg::Typed(_) => None, + }); + + let arg_types = item_method + .sig + .inputs + .iter() + .filter_map(|arg| match arg { + FnArg::Typed(typed_arg) => Some(*typed_arg.ty.clone()), + FnArg::Receiver(_) => None, + }) + .collect::>(); + + let return_type = item_method.sig.output.clone(); + + Self { + ident, + generics: item_method.sig.generics.clone(), + receiver, + mock: mock.clone(), + arg_types, + return_type, + phantom_fields, + } + } + + fn create_phantom_fields( + generic_params: &Punctuated, + ) -> Vec + { + generic_params + .iter() + .filter_map(|generic_param| match generic_param { + GenericParam::Type(type_param) => { + let type_param_ident = &type_param.ident; + + let field_ident = create_phantom_field_ident( + type_param_ident, + &PhantomFieldKind::Type, + ); + + let ty = create_phantom_data_type_path([GenericArgument::Type( + Type::Path(TypePath::new(Path::new( + WithLeadingColons::No, + [PathSegment::new(type_param_ident.clone(), None)], + ))), + )]); + + Some(PhantomField { + field: field_ident, + type_path: ty, + }) + } + GenericParam::Lifetime(lifetime_param) => { + let lifetime = &lifetime_param.lifetime; + + let field_ident = create_phantom_field_ident( + &lifetime.ident, + &PhantomFieldKind::Lifetime, + ); + + let ty = create_phantom_data_type_path([GenericArgument::Type( + Type::Reference(TypeReference::new( + Some(lifetime.clone()), + IsMut::No, + Type::Tuple(create_unit_type_tuple()), + )), + )]); + + Some(PhantomField { + field: field_ident, + type_path: ty, + }) + } + GenericParam::Const(_) => None, + }) + .collect() + } +} + +impl ToTokens for Expectation +{ + fn to_tokens(&self, tokens: &mut TokenStream) + { + let generic_params = &self.generics.params; + + let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl(); + + let bogus_generics = create_bogus_generics(generic_params); + + let opt_self_type = receiver_to_mock_self_type(&self.receiver, self.mock.clone()); + + let ident = &self.ident; + let phantom_fields = &self.phantom_fields; + + let returning_fn = Type::BareFn(TypeBareFn::new( + opt_self_type + .iter() + .chain(self.arg_types.iter()) + .map(|ty| BareFnArg::new(ty.clone())), + self.return_type.clone(), + )); + + let expectation_struct = ItemStruct { + attrs: vec![Attribute::new( + AttributeStyle::Outer, + create_path!(allow), + quote! { (non_camel_case_types, non_snake_case) }, + )], + vis: Visibility::new_pub_crate(), + struct_token: ::default(), + ident: self.ident.clone(), + generics: self.generics.clone().without_where_clause(), + fields: Fields::Named(FieldsNamed { + brace_token: Brace::default(), + named: [Field { + attrs: vec![], + vis: Visibility::Inherited, + ident: Some(format_ident!("returning")), + colon_token: Some(::default()), + ty: Type::Path(TypePath::new(Path::new( + WithLeadingColons::No, + [PathSegment::new( + format_ident!("Option"), + Some(AngleBracketedGenericArguments::new( + WithColons::No, + [GenericArgument::Type(returning_fn.clone())], + )), + )], + ))), + }] + .into_iter() + .chain(phantom_fields.iter().map(|phantom_field| Field { + attrs: vec![], + vis: Visibility::Inherited, + ident: Some(phantom_field.field.clone()), + colon_token: Some(::default()), + ty: Type::Path(phantom_field.type_path.clone()), + })) + .collect(), + }), + semi_token: None, + }; + + quote! { + #expectation_struct + + impl #impl_generics #ident #ty_generics #where_clause + { + fn new() -> Self { + Self { + returning: None, + #(#phantom_fields),* + } + } + + #[allow(unused)] + pub fn returning( + &mut self, + func: #returning_fn + ) -> &mut Self + { + self.returning = Some(func); + + self + } + + #[allow(unused)] + fn strip_generic_params( + self, + ) -> #ident<#(#bogus_generics),*> + { + unsafe { std::mem::transmute(self) } + } + } + + impl #ident<#(#bogus_generics),*> { + #[allow(unused)] + fn with_generic_params<#generic_params>( + &self, + ) -> &#ident #ty_generics + { + // SAFETY: self is a pointer to a sane place, Rustc guarantees that + // by it being a reference. The generic parameters doesn't affect + // the size of self in any way, as they are only used in the function + // pointer field "returning" + unsafe { &*(self as *const Self).cast() } + } + + #[allow(unused)] + fn with_generic_params_mut<#generic_params>( + &mut self, + ) -> &mut #ident #ty_generics + { + // SAFETY: self is a pointer to a sane place, Rustc guarantees that + // by it being a reference. The generic parameters doesn't affect + // the size of self in any way, as they are only used in the function + // pointer field "returning" + unsafe { &mut *(self as *mut Self).cast() } + } + } + } + .to_tokens(tokens); + } +} + +pub fn create_expectation_ident(mock: &Ident, method: &Ident) -> Ident +{ + format_ident!("{mock}Expectation_{method}") +} + +struct PhantomField +{ + field: Ident, + type_path: TypePath, +} + +impl ToTokens for PhantomField +{ + fn to_tokens(&self, tokens: &mut TokenStream) + { + self.field.to_tokens(tokens); + + ::default().to_tokens(tokens); + + self.type_path.to_tokens(tokens); + } +} + +fn create_phantom_field_ident(ident: &Ident, kind: &PhantomFieldKind) -> Ident +{ + match kind { + PhantomFieldKind::Type => format_ident!("{ident}_phantom"), + PhantomFieldKind::Lifetime => format_ident!("{ident}_lt_phantom"), + } +} + +enum PhantomFieldKind +{ + Type, + Lifetime, +} + +fn create_phantom_data_type_path( + generic_args: impl IntoIterator, +) -> TypePath +{ + TypePath::new(Path::new( + WithLeadingColons::Yes, + [ + PathSegment::new(format_ident!("std"), None), + PathSegment::new(format_ident!("marker"), None), + PathSegment::new( + format_ident!("PhantomData"), + Some(AngleBracketedGenericArguments::new( + WithColons::Yes, + generic_args, + )), + ), + ], + )) +} + +fn create_bogus_generics( + generic_params: &Punctuated, +) -> Vec +{ + generic_params + .iter() + .filter_map(|generic_param| match generic_param { + GenericParam::Type(_) => { + Some(GenericArgument::Type(Type::Tuple(create_unit_type_tuple()))) + } + GenericParam::Lifetime(_) => Some(GenericArgument::Lifetime( + Lifetime::create(format_ident!("static")), + )), + GenericParam::Const(_) => None, + }) + .collect() +} + +fn receiver_to_mock_self_type(receiver: &Option, mock: Ident) -> Option +{ + receiver.as_ref().map(|receiver| { + let self_type = Type::Path(TypePath::new(Path::new( + WithLeadingColons::No, + [PathSegment::new(mock, None)], + ))); + + if let Some((_, lifetime)) = &receiver.reference { + return Type::Reference(TypeReference::new( + lifetime.clone(), + receiver.mutability.into(), + self_type, + )); + } + + self_type + }) +} diff --git a/macros/src/lib.rs b/macros/src/lib.rs new file mode 100644 index 0000000..ce91f87 --- /dev/null +++ b/macros/src/lib.rs @@ -0,0 +1,54 @@ +#![deny(clippy::all, clippy::pedantic)] +use proc_macro::TokenStream; +use proc_macro_error::{proc_macro_error, ResultExt}; +use quote::{format_ident, quote}; +use syn::{parse, TraitItem}; + +use crate::expectation::Expectation; +use crate::mock::Mock; +use crate::mock_input::MockInput; + +mod expectation; +mod mock; +mod mock_input; +mod syn_ext; +mod util; + +#[proc_macro] +#[proc_macro_error] +pub fn mock(input_stream: TokenStream) -> TokenStream +{ + let input = parse::(input_stream.clone()).unwrap_or_abort(); + + let mock_ident = input.mock; + + let mock_mod_ident = format_ident!("__{mock_ident}"); + + let method_items = input + .items + .into_iter() + .filter_map(|item| match item { + TraitItem::Method(item_method) => Some(item_method), + _ => None, + }) + .collect::>(); + + let mock = Mock::new(mock_ident.clone(), input.mocked_trait, &method_items); + + let expectations = method_items + .iter() + .map(|item_method| Expectation::new(&mock_ident, item_method)); + + quote! { + mod #mock_mod_ident { + use super::*; + + #mock + + #(#expectations)* + } + + use #mock_mod_ident::#mock_ident; + } + .into() +} diff --git a/macros/src/mock.rs b/macros/src/mock.rs new file mode 100644 index 0000000..88d3434 --- /dev/null +++ b/macros/src/mock.rs @@ -0,0 +1,313 @@ +use proc_macro2::{Ident, Span, TokenStream}; +use proc_macro_error::{abort_call_site, ResultExt}; +use quote::{format_ident, quote, ToTokens}; +use syn::{ + parse2, + AngleBracketedGenericArguments, + FnArg, + GenericArgument, + GenericParam, + ImplItemMethod, + Lifetime, + Pat, + Path, + PathSegment, + Receiver, + ReturnType, + Signature, + Token, + TraitItemMethod, + Type, + TypePath, + TypeReference, + Visibility, +}; + +use crate::expectation::create_expectation_ident; +use crate::syn_ext::{ + AngleBracketedGenericArgumentsExt, + GenericArgumentExt, + IsMut, + PathExt, + PathSegmentExt, + ReturnTypeExt, + SignatureExt, + TypePathExt, + TypeReferenceExt, + VisibilityExt, + WithColons, + WithLeadingColons, +}; +use crate::util::create_unit_type_tuple; + +pub struct Mock +{ + ident: Ident, + mocked_trait: TypePath, + expectations_fields: Vec, + item_methods: Vec, +} + +impl Mock +{ + pub fn new( + ident: Ident, + mocked_trait: TypePath, + item_methods: &[TraitItemMethod], + ) -> Self + { + let expectations_fields = item_methods + .iter() + .map(|method_item| { + let generic_args = method_item + .sig + .generics + .params + .iter() + .filter_map(|generic_param| match generic_param { + GenericParam::Type(_) => Some(GenericArgument::Type( + Type::Tuple(create_unit_type_tuple()), + )), + GenericParam::Lifetime(_) => { + Some(GenericArgument::Lifetime(Lifetime { + apostrophe: Span::call_site(), + ident: format_ident!("static"), + })) + } + GenericParam::Const(_) => None, + }) + .collect::>(); + + ExpectationsField { + field_ident: format_ident!("{}_expectations", method_item.sig.ident), + expectation_ident: create_expectation_ident( + &ident, + &method_item.sig.ident, + ), + generic_args, + } + }) + .collect::>(); + + Self { + ident, + mocked_trait, + expectations_fields, + item_methods: item_methods.to_vec(), + } + } +} + +impl ToTokens for Mock +{ + fn to_tokens(&self, tokens: &mut TokenStream) + { + let Self { + ident, + mocked_trait, + expectations_fields, + item_methods, + } = self; + + let expectations_field_idents = expectations_fields + .iter() + .map(|expectations_field| expectations_field.field_ident.clone()); + + let mock_functions = item_methods + .iter() + .map(|item_method| create_mock_function(item_method.clone())); + + let expect_functions = item_methods + .iter() + .map(|item_method| create_expect_function(&self.ident, &item_method.clone())) + .collect::>(); + + quote! { + pub struct #ident + { + #(#expectations_fields),* + } + + impl #ident + { + pub fn new() -> Self + { + Self { + #( + #expectations_field_idents: ::std::collections::HashMap::new() + ),* + } + } + + #(#expect_functions)* + } + + impl #mocked_trait for #ident { + #( + #mock_functions + )* + } + } + .to_tokens(tokens); + } +} + +struct ExpectationsField +{ + field_ident: Ident, + expectation_ident: Ident, + generic_args: Vec, +} + +impl ToTokens for ExpectationsField +{ + fn to_tokens(&self, tokens: &mut TokenStream) + { + let Self { + field_ident, + expectation_ident, + generic_args, + } = self; + + quote! { + #field_ident: ::std::collections::HashMap< + Vec<::ridicule::__private::type_id::TypeID>, + #expectation_ident<#(#generic_args),*> + > + } + .to_tokens(tokens); + } +} + +fn create_mock_function(item_method: TraitItemMethod) -> ImplItemMethod +{ + let func_ident = &item_method.sig.ident; + + let type_param_idents = item_method + .sig + .generics + .type_params() + .map(|type_param| type_param.ident.clone()) + .collect::>(); + + let args = item_method + .sig + .inputs + .iter() + .map(|fn_arg| match fn_arg { + FnArg::Receiver(_) => format_ident!("self"), + FnArg::Typed(pat_type) => { + let Pat::Ident(pat_ident) = pat_type.pat.as_ref() else { + abort_call_site!("Unsupport argument pattern"); + }; + + pat_ident.ident.clone() + } + }) + .collect::>(); + + let expectations_field = format_ident!("{func_ident}_expectations"); + + let ids = quote! { + let ids = vec![ + #(::ridicule::__private::type_id::TypeID::of::<#type_param_idents>()),* + ]; + }; + + ImplItemMethod { + attrs: item_method.attrs, + vis: Visibility::Inherited, + defaultness: None, + sig: item_method.sig.clone(), + block: parse2(quote! { + { + #ids + + let expectation = self + .#expectations_field + .get(&ids) + .expect(concat!( + "No expectation found for function ", + stringify!(#func_ident) + )) + .with_generic_params::<#(#type_param_idents),*>(); + + let Some(returning) = &expectation.returning else { + panic!(concat!( + "Expectation for function", + stringify!(#func_ident), + " is missing a function to call") + ); + }; + + returning(#(#args),*) + } + }) + .unwrap_or_abort(), + } +} + +fn create_expect_function(mock: &Ident, item_method: &TraitItemMethod) -> ImplItemMethod +{ + let signature = Signature::new( + format_ident!("expect_{}", item_method.sig.ident), + item_method.sig.generics.clone(), + [FnArg::Receiver(Receiver { + attrs: vec![], + reference: Some((::default(), None)), + mutability: Some(::default()), + self_token: ::default(), + })], + ReturnType::new(Type::Reference(TypeReference::new( + None, + IsMut::Yes, + Type::Path(TypePath::new(Path::new( + WithLeadingColons::No, + [PathSegment::new( + create_expectation_ident(mock, &item_method.sig.ident), + Some(AngleBracketedGenericArguments::new( + WithColons::No, + item_method.sig.generics.params.iter().map(|generic_param| { + GenericArgument::from_generic_param(generic_param.clone()) + }), + )), + )], + ))), + ))), + ); + + let type_param_idents = item_method + .sig + .generics + .type_params() + .map(|type_param| type_param.ident.clone()) + .collect::>(); + + let expectation = create_expectation_ident(mock, &item_method.sig.ident); + + let expectations_field = format_ident!("{}_expectations", item_method.sig.ident); + + ImplItemMethod { + attrs: item_method.attrs.clone(), + vis: Visibility::new_pub_crate(), + defaultness: None, + sig: signature, + block: parse2(quote! {{ + let ids = vec![ + #(::ridicule::__private::type_id::TypeID::of::<#type_param_idents>()),* + ]; + + let expectation = + #expectation::<#(#type_param_idents),*>::new() + .strip_generic_params(); + + self.#expectations_field.insert(ids.clone(), expectation); + + self.#expectations_field + .get_mut(&ids) + .unwrap() + .with_generic_params_mut() + }}) + .unwrap_or_abort(), + } +} diff --git a/macros/src/mock_input.rs b/macros/src/mock_input.rs new file mode 100644 index 0000000..379c342 --- /dev/null +++ b/macros/src/mock_input.rs @@ -0,0 +1,51 @@ +use syn::parse::{Parse, ParseStream}; +use syn::{braced, Ident, Token, TraitItem, TypePath, WhereClause}; + +pub struct MockInput +{ + pub mock: Ident, + pub mocked_trait: TypePath, + pub items: Vec, +} + +impl Parse for MockInput +{ + fn parse(input: ParseStream) -> Result + { + let mock = input.parse()?; + + let _generics = input.parse::>()?; + + let _braced_content; + + let _brace = braced!(_braced_content in input); + + input.parse::()?; + + let mocked_trait = input.parse()?; + + input.parse::()?; + + let impl_target = input.parse::()?; + + if impl_target != mock { + return Err(input.error("Expected this to be the mock")); + } + + let content; + + braced!(content in input); + + let mut items = Vec::new(); + + while !content.is_empty() { + items.push(content.parse()?); + } + + Ok(Self { + mock, + mocked_trait, + items, + }) + } +} diff --git a/macros/src/syn_ext.rs b/macros/src/syn_ext.rs new file mode 100644 index 0000000..7a3e9ae --- /dev/null +++ b/macros/src/syn_ext.rs @@ -0,0 +1,372 @@ +use proc_macro2::{Ident, Span, TokenStream}; +use quote::format_ident; +use syn::token::{Bracket, Paren}; +use syn::{ + AngleBracketedGenericArguments, + AttrStyle, + Attribute, + BareFnArg, + FnArg, + GenericArgument, + GenericParam, + Generics, + Lifetime, + Path, + PathArguments, + PathSegment, + ReturnType, + Signature, + Token, + Type, + TypeBareFn, + TypePath, + TypeReference, + VisRestricted, + Visibility, +}; + +pub trait GenericsExt: Sized +{ + fn without_where_clause(self) -> Self; +} + +impl GenericsExt for Generics +{ + fn without_where_clause(mut self) -> Self + { + self.where_clause = None; + + self + } +} + +pub trait AttributeExt: Sized +{ + fn new(style: AttributeStyle, path: Path, token_stream: TokenStream) -> Self; +} + +impl AttributeExt for Attribute +{ + fn new(style: AttributeStyle, path: Path, token_stream: TokenStream) -> Self + { + Self { + pound_token: ::default(), + style: style.into(), + bracket_token: Bracket::default(), + path, + tokens: token_stream, + } + } +} + +pub enum AttributeStyle +{ + /// A outer attribute. For example like `#[repr(C)]`. + Outer, + + /// A inner attribute. For example like `#![deny(clippy::all)]`. + Inner, +} + +impl From for AttrStyle +{ + fn from(style: AttributeStyle) -> Self + { + match style { + AttributeStyle::Outer => Self::Outer, + AttributeStyle::Inner => Self::Inner(::default()), + } + } +} + +pub trait VisibilityExt: Sized +{ + /// Returns a new `pub(crate)` visibility. + fn new_pub_crate() -> Self; +} + +impl VisibilityExt for Visibility +{ + fn new_pub_crate() -> Self + { + Self::Restricted(VisRestricted { + pub_token: ::default(), + paren_token: Paren::default(), + in_token: None, + path: Box::new(Path::new( + WithLeadingColons::No, + [PathSegment::new(format_ident!("crate"), None)], + )), + }) + } +} + +pub trait PathExt: Sized +{ + fn new( + with_leading_colons: WithLeadingColons, + segments: impl IntoIterator, + ) -> Self; +} + +impl PathExt for Path +{ + fn new( + with_leading_colons: WithLeadingColons, + segments: impl IntoIterator, + ) -> Self + { + Self { + leading_colon: match with_leading_colons { + WithLeadingColons::Yes => Some(::default()), + WithLeadingColons::No => None, + }, + segments: segments.into_iter().collect(), + } + } +} + +pub enum WithLeadingColons +{ + Yes, + No, +} + +pub trait PathSegmentExt: Sized +{ + fn new(ident: Ident, args: Option) -> Self; +} + +impl PathSegmentExt for PathSegment +{ + fn new(ident: Ident, args: Option) -> Self + { + Self { + ident, + arguments: args + .map_or_else(|| PathArguments::None, PathArguments::AngleBracketed), + } + } +} + +pub trait AngleBracketedGenericArgumentsExt: Sized +{ + fn new( + with_colons: WithColons, + generic_args: impl IntoIterator, + ) -> Self; +} + +impl AngleBracketedGenericArgumentsExt for AngleBracketedGenericArguments +{ + fn new( + with_colons: WithColons, + generic_args: impl IntoIterator, + ) -> Self + { + Self { + colon2_token: match with_colons { + WithColons::Yes => Some(::default()), + WithColons::No => None, + }, + lt_token: ::default(), + args: generic_args.into_iter().collect(), + gt_token: <::syn::Token![>]>::default(), + } + } +} + +pub enum WithColons +{ + Yes, + No, +} + +pub trait TypeReferenceExt: Sized +{ + fn new(lifetime: Option, is_mut: IsMut, inner_type: Type) -> Self; +} + +impl TypeReferenceExt for TypeReference +{ + fn new(lifetime: Option, is_mut: IsMut, inner_type: Type) -> Self + { + Self { + and_token: ::default(), + lifetime, + mutability: is_mut.into(), + elem: Box::new(inner_type), + } + } +} + +pub enum IsMut +{ + Yes, + No, +} + +impl From> for IsMut +{ + fn from(opt_mut: Option) -> Self + { + match opt_mut { + Some(_) => Self::Yes, + None => Self::No, + } + } +} + +impl From for Option +{ + fn from(is_mut: IsMut) -> Self + { + match is_mut { + IsMut::Yes => Some(Self::None.unwrap_or_default()), + IsMut::No => None, + } + } +} + +pub trait SignatureExt: Sized +{ + fn new( + ident: Ident, + generics: Generics, + inputs: impl IntoIterator, + output: ReturnType, + ) -> Self; +} + +impl SignatureExt for Signature +{ + fn new( + ident: Ident, + generics: Generics, + inputs: impl IntoIterator, + output: ReturnType, + ) -> Self + { + Self { + constness: None, + asyncness: None, + unsafety: None, + abi: None, + fn_token: ::default(), + ident, + generics, + paren_token: Paren::default(), + inputs: inputs.into_iter().collect(), + variadic: None, + output, + } + } +} + +pub trait ReturnTypeExt: Sized +{ + /// Returns a new `ReturnType::Type`. + fn new(ty: Type) -> Self; +} + +impl ReturnTypeExt for ReturnType +{ + fn new(ty: Type) -> Self + { + Self::Type(]>::default(), Box::new(ty)) + } +} + +pub trait GenericArgumentExt: Sized +{ + fn from_generic_param(generic_param: GenericParam) -> Self; +} + +impl GenericArgumentExt for GenericArgument +{ + fn from_generic_param(generic_param: GenericParam) -> Self + { + match generic_param { + GenericParam::Type(type_param) => { + GenericArgument::Type(Type::Path(TypePath::new(Path::new( + WithLeadingColons::No, + [PathSegment::new(type_param.ident, None)], + )))) + } + GenericParam::Lifetime(lifetime_param) => { + GenericArgument::Lifetime(lifetime_param.lifetime) + } + GenericParam::Const(_) => { + todo!(); + } + } + } +} + +pub trait TypePathExt: Sized +{ + fn new(path: Path) -> Self; +} + +impl TypePathExt for TypePath +{ + fn new(path: Path) -> Self + { + Self { qself: None, path } + } +} + +pub trait TypeBareFnExt: Sized +{ + fn new(inputs: impl IntoIterator, output: ReturnType) -> Self; +} + +impl TypeBareFnExt for TypeBareFn +{ + fn new(inputs: impl IntoIterator, output: ReturnType) -> Self + { + Self { + lifetimes: None, + unsafety: None, + abi: None, + fn_token: ::default(), + paren_token: Paren::default(), + inputs: inputs.into_iter().collect(), + variadic: None, + output, + } + } +} + +pub trait LifetimeExt: Sized +{ + fn create(ident: Ident) -> Self; +} + +impl LifetimeExt for Lifetime +{ + fn create(ident: Ident) -> Self + { + Self { + apostrophe: Span::call_site(), + ident, + } + } +} + +pub trait BareFnArgExt: Sized +{ + fn new(ty: Type) -> Self; +} + +impl BareFnArgExt for BareFnArg +{ + fn new(ty: Type) -> Self + { + Self { + attrs: vec![], + name: None, + ty, + } + } +} diff --git a/macros/src/util.rs b/macros/src/util.rs new file mode 100644 index 0000000..363051f --- /dev/null +++ b/macros/src/util.rs @@ -0,0 +1,22 @@ +use syn::punctuated::Punctuated; +use syn::token::Paren; +use syn::TypeTuple; + +pub fn create_unit_type_tuple() -> TypeTuple +{ + TypeTuple { + paren_token: Paren::default(), + elems: Punctuated::new(), + } +} + +macro_rules! create_path { + ($($segment: ident)::+) => { + Path::new( + WithLeadingColons::No, + [$(PathSegment::new(format_ident!(stringify!($segment)), None))+], + ) + }; +} + +pub(crate) use create_path; -- cgit v1.2.3-18-g5258