Method derive

bitcode_derive/src/shared.rs:92–152

(&self, mut input: DeriveInput)

    }

    fn derive(&self, mut input: DeriveInput) -> Result<TokenStream> {
        let attrs = BitcodeAttrs::parse_derive(&input.attrs)?;
        let ident = input.ident;
        syn::visit_mut::visit_data_mut(&mut ReplaceSelves(&ident), &mut input.data);
        let mut bounds = FieldBounds::default();

        let output = match input.data {
            Data::Struct(DataStruct { ref fields, .. }) => {
                // Only used for adding `bounds`. Would be used by `#[bitcode(with_serde)]`.
                let field_attrs = self.field_attrs(fields, &attrs, &mut bounds)?;
                let _ = field_attrs;

                let destructure_fields = &destructure_fields(fields);
                Self::ALL.map(|item| {
                    let field_impls = item.field_impls(None, fields);
                    item.struct_impl(&ident, destructure_fields, &field_impls)
                })
            }
            Data::Enum(data_enum) => {
                let max_variants = VariantIndex::MAX as usize + 1;
                if data_enum.variants.len() > max_variants {
                    return err(
                        &ident,
                        &format!("enums with more than {max_variants} variants are not supported"),
                    );
                }

                // Only used for adding `bounds`. Would be used by `#[bitcode(with_serde)]`.
                let variant_attrs = data_enum
                    .variants
                    .iter()
                    .map(|variant| {
                        let attrs = BitcodeAttrs::parse_variant(&variant.attrs, &attrs)?;
                        self.field_attrs(&variant.fields, &attrs, &mut bounds)
                    })
                    .collect::<Result<Vec<_>>>()?;
                let _ = variant_attrs;

                Self::ALL.map(|item| {
                    item.enum_impl(
                        data_enum.variants.len(),
                        |i| {
                            let variant = &data_enum.variants[i];
                            let variant_name = &variant.ident;
                            let destructure_fields = destructure_fields(&variant.fields);
                            quote! {
                                #ident::#variant_name #destructure_fields
                            }
                        },
                        |item, i| {
                            let variant = &data_enum.variants[i];
                            let global_prefix = format!("{}_", &variant.ident);
                            item.field_impls(Some(&global_prefix), &variant.fields)
                        },
                    )
                })
            }
            Data::Union(_) => err(&ident, "unions are not supported")?,