1#![forbid(unsafe_code)]
5#![warn(missing_docs)]
6
7use proc_macro::TokenStream;
8
9use proc_macro_crate::{FoundCrate, crate_name};
10use quote::{format_ident, quote};
11use syn::{
12 Data, DeriveInput, Error, Field, Fields, Ident, Result, Type, parse_macro_input, parse_quote,
13};
14
15#[proc_macro_derive(ToInputVector, attributes(input))]
22pub fn derive_to_input_vector(input: TokenStream) -> TokenStream {
23 let input = parse_macro_input!(input as DeriveInput);
24
25 match expand(input) {
26 Ok(tokens) => tokens.into(),
27 Err(error) => error.into_compile_error().into(),
28 }
29}
30
31fn expand(input: DeriveInput) -> Result<proc_macro2::TokenStream> {
32 let crate_path = to_values_path(&input.ident);
33 let ident = input.ident;
34 let fields = match input.data {
35 Data::Struct(data) => data.fields,
36 Data::Enum(_) | Data::Union(_) => {
37 return Err(Error::new_spanned(
38 ident,
39 "ToInputVector can only be derived for structs",
40 ));
41 }
42 };
43
44 let fields = included_fields(fields)?;
45 let mut generics = input.generics;
46 let where_clause = generics.make_where_clause();
47 for (_, field_type) in &fields {
48 where_clause
49 .predicates
50 .push(parse_quote!(#field_type: #crate_path::ToInputVector));
51 }
52
53 let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
54 let lengths = fields.iter().map(|(member, _)| {
55 quote!(
56 length = length.saturating_add(
57 #crate_path::ToInputVector::input_vector_len(&self.#member)
58 );
59 )
60 });
61 let appends = fields.iter().map(|(member, _)| {
62 quote!(#crate_path::ToInputVector::append_input_vector(&self.#member, output);)
63 });
64
65 Ok(quote! {
66 #[automatically_derived]
67 impl #impl_generics #crate_path::ToInputVector for #ident #type_generics #where_clause {
68 #[inline]
69 fn input_vector_len(&self) -> usize {
70 let mut length = 0usize;
71 #(#lengths)*
72 length
73 }
74
75 #[inline]
76 fn append_input_vector(&self, output: &mut #crate_path::__InputVector) {
77 #(#appends)*
78 }
79 }
80 })
81}
82
83fn to_values_path(derive_target: &Ident) -> proc_macro2::TokenStream {
84 match crate_name("to-values") {
85 Ok(FoundCrate::Itself) => quote!(::to_values),
88 Ok(FoundCrate::Name(name)) => {
89 let crate_ident = format_ident!("{}", name, span = derive_target.span());
90 quote!(::#crate_ident)
91 }
92 Err(_) => quote!(::to_values),
93 }
94}
95
96fn included_fields(fields: Fields) -> Result<Vec<(proc_macro2::TokenStream, Type)>> {
97 fields
98 .iter()
99 .enumerate()
100 .filter_map(|(index, field)| match field_is_skipped(field) {
101 Ok(true) => None,
102 Ok(false) => Some(Ok((field_member(field, index), field.ty.clone()))),
103 Err(error) => Some(Err(error)),
104 })
105 .collect()
106}
107
108fn field_member(field: &Field, index: usize) -> proc_macro2::TokenStream {
109 match &field.ident {
110 Some(ident) => quote!(#ident),
111 None => {
112 let index = syn::Index::from(index);
113 quote!(#index)
114 }
115 }
116}
117
118fn field_is_skipped(field: &Field) -> Result<bool> {
119 let mut skipped = false;
120
121 for attribute in &field.attrs {
122 if !attribute.path().is_ident("input") {
123 continue;
124 }
125
126 let mut has_argument = false;
127 attribute.parse_nested_meta(|meta| {
128 has_argument = true;
129 if meta.path.is_ident("skip") && meta.input.is_empty() {
130 skipped = true;
131 Ok(())
132 } else {
133 Err(meta.error("expected `#[input(skip)]`"))
134 }
135 })?;
136
137 if !has_argument {
138 return Err(Error::new_spanned(attribute, "expected `#[input(skip)]`"));
139 }
140 }
141
142 Ok(skipped)
143}