11355852092

Committed 15 Oct 2024 11:15PM UTC coverage: 91.667%. Remained the same

Build # 11355852092

Build Type

push

github

Committed by

Alorel

Commit Message

refactor: Migrate to `macroific` v2

BREAKING CHANGE: msrv bumped to 1.71 & `nightly` feature removed

Run Details

44 of 45 new or added lines in 2 files covered. (97.78%)

1 existing line in 1 file now uncovered.

374 of 408 relevant lines covered (91.67%)

8.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.11

/src/derive_accessors.rs

use macroific::elements::GenericImpl;
use macroific::prelude::*;
use proc_macro2::{Delimiter, Group, Ident, TokenStream};
use quote::{format_ident, quote, ToTokens, TokenStreamExt};
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{Attribute, DeriveInput, Generics, Token, Type};

use options::*;
use parsed_field::*;

use crate::derive_accessors::final_options::{FinalOptions, Naming};

mod final_options;
pub mod options;
mod parsed_field;

const ATTR_NAME: &str = "access";

pub struct DeriveAccessors {
    fields: Vec<ParsedField>,
    container_opts: ContainerOptions,
    ident: Ident,
    generics: Generics,
}

impl ToTokens for DeriveAccessors {
    fn to_tokens(&self, _: &mut TokenStream) {
        unimplemented!("Use `into_token_stream`")
    }

    fn into_token_stream(self) -> TokenStream
    where
        Self: Sized,
    {
        macro_rules! variations {
            (
                [
                    $final_opts: ident,
                    $container_opts: ident,
                    $naming: ident,
                    $opts: ident,
                    $tokens: ident,
                    $ident: ident,
                    $comments: ident,
                    $ty: ident
                ] => $([$lower: ident $upper: ident $render: ident]),+
                | [$last_lower: ident $last_upper: ident $last_render: ident]
            ) => {
                $(
                    match $final_opts::new(
                        $container_opts.$lower,
                        &$container_opts.defaults.$lower,
                        &$naming::$upper,
                        $opts.$lower,
                        &$opts.all,
                        &$container_opts.defaults.all,
                    ) {
                        Some(opts) if !opts.skip => {
                            let a = ::syn::parse_quote!(#[must_use]);
                            render_common(&mut $tokens, &$ident, &$comments, &opts, Some(a));
                            $tokens.extend($render(&$ident, &$ty, opts));
                        },
                        _ => {},
                    }
                )+

                match $final_opts::new(
                    $container_opts.$last_lower,
                    &$container_opts.defaults.$last_lower,
                    &$naming::$last_upper,
                    $opts.$last_lower,
                    &$opts.all,
                    &$container_opts.defaults.all,
                ) {
                    Some(opts) if !opts.skip => {
                        render_common(&mut $tokens, &$ident, &$comments, &opts, None);
                        $tokens.extend($last_render($ident, $ty, opts));
                    },
                    _ => {},
                }
            };
        }

        let Self {
            fields,
            container_opts,
            ident,
            mut generics,
        } = self;

        let mut out = {
            if !container_opts.bounds.is_empty() {
                generics
                    .make_where_clause()
                    .predicates
                    .extend(container_opts.bounds);
            }

            let header = GenericImpl::new(generics).with_target(ident);
            quote! {
                #[automatically_derived]
                #[allow(clippy::all)]
                #header
            }
        };

        out.append(Group::new(Delimiter::Brace, {
            let mut tokens = TokenStream::new();

            for field in fields {
                let ParsedField {
                    comments,
                    opts,
                    ident,
                    ty,
                } = field;

                if opts.skip {
                    continue;
                }

                variations!(
                    [FinalOptions, container_opts, Naming, opts, tokens, ident, comments, ty] =>
                    [get GET RENDER_GET],
                    [get_mut GET_MUT RENDER_GET_MUT]
                    | [set SET RENDER_SET]
                );
            }

            tokens
        }));

        out
    }
}

#[allow(clippy::needless_pass_by_value)]
fn render_common(
    tokens: &mut TokenStream,
    ident: &Ident,
    comments: &[Attribute],
    opts: &FinalOptions,
    must_use: Option<Attribute>,
) {
    let vis = &opts.vis;
    tokens.extend(quote! {
        #(#comments)*
        #[inline]
        #must_use
        #vis
    });

    if opts.const_fn {
        tokens.append(Ident::create("const"));
    }

    tokens.append(Ident::create("fn"));

    tokens.append(match (&opts.prefix, &opts.suffix) {
        (Some(p), Some(s)) => format_ident!("{}{ident}{}", p.as_prefix(), s.as_suffix()),
        (Some(p), None) => format_ident!("{}{ident}", p.as_prefix()),
        (None, Some(s)) => format_ident!("{ident}{}", s.as_suffix()),
        (None, None) => ident.clone(),
    });
}

fn arg_ref(owned: bool) -> Option<Token![&]> {
    if owned {
        None
    } else {
        Some(<Token![&]>::default())
    }
}

fn mk_where<T, P>(bounds: Punctuated<T, P>) -> Option<TokenStream>
where
    Punctuated<T, P>: ToTokens,
{
    if bounds.is_empty() {
        None
    } else {
        Some(quote!(where #bounds))
    }
}

fn resolve_ptr_ty(base: &Type, opt: Option<DerefKind>) -> &Type {
    match (opt, base) {
        (Some(_), Type::Ptr(ptr)) => &ptr.elem,
        (_, ty) => ty,
    }
}

type RenderFieldFn = fn(&Ident, &Type, FinalOptions) -> TokenStream;
type LastRenderFieldFn = fn(Ident, Type, FinalOptions) -> TokenStream;

const RENDER_GET: RenderFieldFn = |ident, ty, opts| {
    let arg_ref = arg_ref(opts.owned);

    let val_ref = if opts.cp || opts.owned {
        None
    } else if let Some(deref) = opts.ptr_deref {
        let tokens = deref.try_into_tokens().unwrap_or_else(move || quote!(&));
        Some(tokens)
    } else {
        Some(quote!(&))
    };

    let fn_return = if let Some(ty) = opts.ty {
        ty.into_token_stream()
    } else {
        let ty = resolve_ptr_ty(ty, opts.ptr_deref);
        quote!(#val_ref #ty)
    };

    let where_clause = mk_where(opts.bounds);

    let body = if opts.ptr_deref.is_some() {
        quote!(unsafe { #val_ref *self.#ident })
    } else {
        quote!(#val_ref self.#ident)
    };

    quote!((#arg_ref self) -> #fn_return #where_clause { #body })
};

const RENDER_GET_MUT: RenderFieldFn = |ident, ty, opts| {
    let fn_return = if let Some(ty) = opts.ty {
        ty.into_token_stream()
    } else {
        let ty = resolve_ptr_ty(ty, opts.ptr_deref);
        quote!(&mut #ty)
    };

    let where_clause = mk_where(opts.bounds);

    let body = if opts.ptr_deref.is_some() {
        quote!(unsafe { &mut *self.#ident })
    } else {
        quote!(&mut self.#ident)
    };

    quote!((&mut self) -> #fn_return #where_clause { #body })
};

const RENDER_SET: LastRenderFieldFn = |ident, ty, opts| {
    let arg_ref = arg_ref(opts.owned);

    let self_ref = if opts.cp || opts.owned {
        None
    } else {
        Some(quote!(&mut))
    };

    let arg_ty = if let Some(ref ty) = opts.ty {
        ty
    } else {
        resolve_ptr_ty(&ty, opts.ptr_deref)
    };

    let where_clause = mk_where(opts.bounds);

    let assignment = if opts.ptr_deref.is_some() {
        quote! { unsafe { *self.#ident = new_value; } }
    } else {
        quote! { self.#ident = new_value }
    };

    quote! {
        (#arg_ref mut self, new_value: #arg_ty) -> #self_ref Self #where_clause {
            #assignment;
            self
        }
    }
};

impl Parse for DeriveAccessors {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let DeriveInput {
            attrs,
            ident,
            generics,
            data,
            ..
        } = input.parse()?;

        let container_opts = ContainerOptions::from_iter_named(ATTR_NAME, ident.span(), attrs)?;
        let fields = data
            .extract_struct_named()?
            .into_iter()
            .map(ParsedField::try_from);

        Ok(Self {
            fields: fields.collect::<syn::Result<_>>()?,
            container_opts,
            ident,
            generics,
        })
    }
}

1	use macroific::elements::GenericImpl;
2	use macroific::prelude::*;
3	use proc_macro2::{Delimiter, Group, Ident, TokenStream};
4	use quote::{format_ident, quote, ToTokens, TokenStreamExt};
5	use syn::parse::{Parse, ParseStream};
6	use syn::punctuated::Punctuated;
7	use syn::{Attribute, DeriveInput, Generics, Token, Type};
8
9	use options::*;
10	use parsed_field::*;
11
12	use crate::derive_accessors::final_options::{FinalOptions, Naming};
13
14	mod final_options;
15	pub mod options;
16	mod parsed_field;
17
18	const ATTR_NAME: &str = "access";
19
20	pub struct DeriveAccessors {
21	fields: Vec<ParsedField>,
22	container_opts: ContainerOptions,
23	ident: Ident,
24	generics: Generics,
25	}
26
27	impl ToTokens for DeriveAccessors {
28	fn to_tokens(&self, _: &mut TokenStream) {	×
NEW 29	unimplemented!("Use `into_token_stream`")	×
30	}
31
32	fn into_token_stream(self) -> TokenStream	5✔
33	where	5✔
34	Self: Sized,	5✔
35	{	5✔
36	macro_rules! variations {
37	(
38	[
39	$final_opts: ident,
40	$container_opts: ident,
41	$naming: ident,
42	$opts: ident,
43	$tokens: ident,
44	$ident: ident,
45	$comments: ident,
46	$ty: ident
47	] => $([$lower: ident $upper: ident $render: ident]),+
48	\| [$last_lower: ident $last_upper: ident $last_render: ident]
49	) => {
50	$(
51	match $final_opts::new(
52	$container_opts.$lower,
53	&$container_opts.defaults.$lower,
54	&$naming::$upper,
55	$opts.$lower,
56	&$opts.all,
57	&$container_opts.defaults.all,
58	) {
59	Some(opts) if !opts.skip => {
60	let a = ::syn::parse_quote!(#[must_use]);
61	render_common(&mut $tokens, &$ident, &$comments, &opts, Some(a));
62	$tokens.extend($render(&$ident, &$ty, opts));
63	},
64	_ => {},
65	}
66	)+
67
68	match $final_opts::new(
69	$container_opts.$last_lower,
70	&$container_opts.defaults.$last_lower,
71	&$naming::$last_upper,
72	$opts.$last_lower,
73	&$opts.all,
74	&$container_opts.defaults.all,
75	) {
76	Some(opts) if !opts.skip => {
77	render_common(&mut $tokens, &$ident, &$comments, &opts, None);
78	$tokens.extend($last_render($ident, $ty, opts));
79	},
80	_ => {},
81	}
82	};
83	}
84
85	let Self {
86	fields,	5✔
87	container_opts,	5✔
88	ident,	5✔
89	mut generics,	5✔
90	} = self;	5✔
91
92	let mut out = {	5✔
93	if !container_opts.bounds.is_empty() {	5✔
94	generics	1✔
95	.make_where_clause()	1✔
96	.predicates	1✔
97	.extend(container_opts.bounds);	1✔
98	}	4✔
99
100	let header = GenericImpl::new(generics).with_target(ident);	5✔
101	quote! {	5✔
102	#[automatically_derived]	5✔
103	#[allow(clippy::all)]	5✔
104	#header	5✔
105	}	5✔
106	};	5✔
107		5✔
108	out.append(Group::new(Delimiter::Brace, {	5✔
109	let mut tokens = TokenStream::new();	5✔
110
111	for field in fields {	17✔
112	let ParsedField {
113	comments,	12✔
114	opts,	12✔
115	ident,	12✔
116	ty,	12✔
117	} = field;	12✔
118		12✔
119	if opts.skip {	12✔
120	continue;	1✔
121	}	11✔
122		11✔
123	variations!(	11✔
124	[FinalOptions, container_opts, Naming, opts, tokens, ident, comments, ty] =>	11✔
125	[get GET RENDER_GET],	11✔
126	[get_mut GET_MUT RENDER_GET_MUT]	11✔
127	\| [set SET RENDER_SET]	11✔
128	);	11✔
129	}
130
131	tokens	5✔
132	}));	5✔
133		5✔
134	out	5✔
135	}	5✔
136	}
137
138	#[allow(clippy::needless_pass_by_value)]
139	fn render_common(	22✔
140	tokens: &mut TokenStream,	22✔
141	ident: &Ident,	22✔
142	comments: &[Attribute],	22✔
143	opts: &FinalOptions,	22✔
144	must_use: Option<Attribute>,	22✔
145	) {	22✔
146	let vis = &opts.vis;	22✔
147	tokens.extend(quote! {	22✔
148	#(#comments)*	22✔
149	#[inline]	22✔
150	#must_use	22✔
151	#vis	22✔
152	});	22✔
153
154	if opts.const_fn {	22✔
155	tokens.append(Ident::create("const"));	5✔
156	}	17✔
157
158	tokens.append(Ident::create("fn"));	22✔
159		22✔
160	tokens.append(match (&opts.prefix, &opts.suffix) {	22✔
161	(Some(p), Some(s)) => format_ident!("{}{ident}{}", p.as_prefix(), s.as_suffix()),	1✔
162	(Some(p), None) => format_ident!("{}{ident}", p.as_prefix()),	6✔
163	(None, Some(s)) => format_ident!("{ident}{}", s.as_suffix()),	6✔
164	(None, None) => ident.clone(),	9✔
165	});
166	}	22✔
167
168	fn arg_ref(owned: bool) -> Option<Token![&]> {	16✔
169	if owned {	16✔
170	None	3✔
171	} else {
172	Some(<Token![&]>::default())	13✔
173	}
174	}	16✔
175
176	fn mk_where<T, P>(bounds: Punctuated<T, P>) -> Option<TokenStream>	22✔
177	where	22✔
178	Punctuated<T, P>: ToTokens,	22✔
179	{	22✔
180	if bounds.is_empty() {	22✔
181	None	21✔
182	} else {
183	Some(quote!(where #bounds))	1✔
184	}
185	}	22✔
186
187	fn resolve_ptr_ty(base: &Type, opt: Option<DerefKind>) -> &Type {	19✔
188	match (opt, base) {	19✔
189	(Some(_), Type::Ptr(ptr)) => &ptr.elem,	7✔
190	(_, ty) => ty,	12✔
191	}
192	}	19✔
193
194	type RenderFieldFn = fn(&Ident, &Type, FinalOptions) -> TokenStream;
195	type LastRenderFieldFn = fn(Ident, Type, FinalOptions) -> TokenStream;
196
197	const RENDER_GET: RenderFieldFn = \|ident, ty, opts\| {	10✔
198	let arg_ref = arg_ref(opts.owned);	10✔
199
200	let val_ref = if opts.cp \|\| opts.owned {	10✔
201	None	5✔
202	} else if let Some(deref) = opts.ptr_deref {	5✔
203	let tokens = deref.try_into_tokens().unwrap_or_else(move \|\| quote!(&));	3✔
204	Some(tokens)	3✔
205	} else {
206	Some(quote!(&))	2✔
207	};
208
209	let fn_return = if let Some(ty) = opts.ty {	10✔
210	ty.into_token_stream()	2✔
211	} else {
212	let ty = resolve_ptr_ty(ty, opts.ptr_deref);	8✔
213	quote!(#val_ref #ty)	8✔
214	};
215
216	let where_clause = mk_where(opts.bounds);	10✔
217
218	let body = if opts.ptr_deref.is_some() {	10✔
219	quote!(unsafe { #val_ref *self.#ident })	4✔
220	} else {
221	quote!(#val_ref self.#ident)	6✔
222	};
223
224	quote!((#arg_ref self) -> #fn_return #where_clause { #body })	10✔
225	};	10✔
226
227	const RENDER_GET_MUT: RenderFieldFn = \|ident, ty, opts\| {	6✔
228	let fn_return = if let Some(ty) = opts.ty {	6✔
229	ty.into_token_stream()	1✔
230	} else {
231	let ty = resolve_ptr_ty(ty, opts.ptr_deref);	5✔
232	quote!(&mut #ty)	5✔
233	};
234
235	let where_clause = mk_where(opts.bounds);	6✔
236
237	let body = if opts.ptr_deref.is_some() {	6✔
238	quote!(unsafe { &mut *self.#ident })	3✔
239	} else {
240	quote!(&mut self.#ident)	3✔
241	};
242
243	quote!((&mut self) -> #fn_return #where_clause { #body })	6✔
244	};	6✔
245
246	const RENDER_SET: LastRenderFieldFn = \|ident, ty, opts\| {	6✔
247	let arg_ref = arg_ref(opts.owned);	6✔
248
249	let self_ref = if opts.cp \|\| opts.owned {	6✔
250	None	3✔
251	} else {
252	Some(quote!(&mut))	3✔
253	};
254
255	let arg_ty = if let Some(ref ty) = opts.ty {	6✔
UNCOV 256	ty	×
257	} else {
258	resolve_ptr_ty(&ty, opts.ptr_deref)	6✔
259	};
260
261	let where_clause = mk_where(opts.bounds);	6✔
262
263	let assignment = if opts.ptr_deref.is_some() {	6✔
264	quote! { unsafe { *self.#ident = new_value; } }	2✔
265	} else {
266	quote! { self.#ident = new_value }	4✔
267	};
268
269	quote! {	6✔
270	(#arg_ref mut self, new_value: #arg_ty) -> #self_ref Self #where_clause {	6✔
271	#assignment;	6✔
272	self	6✔
273	}	6✔
274	}	6✔
275	};	6✔
276
277	impl Parse for DeriveAccessors {
278	fn parse(input: ParseStream) -> syn::Result<Self> {	5✔
279	let DeriveInput {
280	attrs,	5✔
281	ident,	5✔
282	generics,	5✔
283	data,	5✔
284	..
285	} = input.parse()?;	5✔
286
287	let container_opts = ContainerOptions::from_iter_named(ATTR_NAME, ident.span(), attrs)?;	5✔
288	let fields = data	5✔
289	.extract_struct_named()?	5✔
290	.into_iter()	5✔
291	.map(ParsedField::try_from);	5✔
292		5✔
293	Ok(Self {	5✔
294	fields: fields.collect::<syn::Result<_>>()?,	5✔
295	container_opts,	5✔
296	ident,	5✔
297	generics,	5✔
298	})
299	}	5✔
300	}

Alorel / accessory-rs / 11355852092

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous