Function derive_diff

crates/firewheel-macros/src/diff.rs:8–62

(input: TokenStream)

use crate::{TypeSet, get_paths, struct_fields};

pub fn derive_diff(input: TokenStream) -> syn::Result<TokenStream2> {
    let input: syn::DeriveInput = syn::parse(input)?;
    let identifier = &input.ident;
    let (firewheel_path, diff_path) = get_paths();

    let (impl_generics, ty_generics, where_generics) = input.generics.split_for_impl();

    fn generate_where(
        where_clause: Option<&syn::WhereClause>,
        bounds: &[TokenStream2],
    ) -> TokenStream2 {
        match where_clause {
            Some(wg) => {
                quote! {
                    #wg
                    #(#bounds,)*
                }
            }
            None => {
                quote! {
                    where #(#bounds,)*
                }
            }
        }
    }

    let (body, where_generics) = match &input.data {
        syn::Data::Struct(data) => {
            let DiffOutput { body, bounds } = DiffOutput::from_struct(data, &diff_path)?;

            (body, generate_where(where_generics, &bounds))
        }
        syn::Data::Enum(data) => {
            let DiffOutput { body, bounds } =
                DiffOutput::from_enum(identifier, data, &firewheel_path, &diff_path)?;

            (body, generate_where(where_generics, &bounds))
        }
        syn::Data::Union(_) => {
            return Err(syn::Error::new(
                input.span(),
                "`Diff` cannot be derived on unions.",
            ));
        }
    };

    Ok(quote! {
        #[automatically_derived]
        impl #impl_generics #diff_path::Diff for #identifier #ty_generics #where_generics {
            fn diff<__E: #diff_path::EventQueue>(&self, baseline: &Self, path: #diff_path::PathBuilder, event_queue: &mut __E) {
                #body
            }
        }
    })
}

struct DiffOutput {
    body: TokenStream2,