Skip to main content

to_values_derive/
lib.rs

1//! Procedural macro implementation for
2//! [`to_values::ToInputVector`](https://docs.rs/to-values/latest/to_values/trait.ToInputVector.html).
3
4#![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/// Derives
16/// [`to_values::ToInputVector`](https://docs.rs/to-values/latest/to_values/trait.ToInputVector.html)
17/// for a struct.
18///
19/// Fields are flattened in declaration order. Mark a field with `#[input(skip)]`
20/// to leave it out of both the output vector and its capacity calculation.
21#[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        // This macro lives in a companion crate, so even doctests for
86        // `to-values` must refer to it through an external-crate path.
87        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}