Function generate_default_impl

rust/fory-derive/src/object/serializer.rs:343–483

(
    ast: &syn::DeriveInput,
    generate_default: bool,
)

}

fn generate_default_impl(
    ast: &syn::DeriveInput,
    generate_default: bool,
) -> proc_macro2::TokenStream {
    let name = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();

    // By default, we don't generate Default impl to avoid conflicts.
    // Only generate if generate_default is true AND there's no existing Default.
    let should_generate_default = generate_default && !has_existing_default(ast, "Default");

    match &ast.data {
        Data::Struct(s) => {
            let source_fields = source_fields(&s.fields);
            let is_tuple_struct = source_fields
                .first()
                .map(|sf| sf.is_tuple_struct)
                .unwrap_or(false);

            // Generate field initializations with original index for sorting
            let mut indexed: Vec<_> = source_fields
                .iter()
                .map(|sf| {
                    let value = super::field_codec::default_expr_for_type(&sf.field.ty);
                    (sf.original_index, sf.field_init(value))
                })
                .collect();

            // For tuple structs, sort by original index
            if is_tuple_struct {
                indexed.sort_by_key(|(idx, _)| *idx);
            }

            let field_inits: Vec<_> = indexed.into_iter().map(|(_, ts)| ts).collect();
            let self_construction = crate::util::self_construction(is_tuple_struct, &field_inits);

            if should_generate_default {
                // User requested Default generation via #[fory(generate_default)]
                quote! {
                    impl #impl_generics fory_core::ForyDefault for #name #ty_generics #where_clause {
                        fn fory_default() -> Self {
                            #self_construction
                        }
                    }
                    impl #impl_generics ::std::default::Default for #name #ty_generics #where_clause {
                        fn default() -> Self {
                            Self::fory_default()
                        }
                    }
                }
            } else {
                // Default case: only generate ForyDefault, not Default
                // This avoids conflicts with existing Default implementations
                quote! {
                   impl #impl_generics fory_core::ForyDefault for #name #ty_generics #where_clause {
                        fn fory_default() -> Self {
                            #self_construction
                        }