Interface Derive

bitcode_derive/src/shared.rs:61–153

}

pub trait Derive<const ITEM_COUNT: usize> {
    type Item: Item;
    const ALL: [Self::Item; ITEM_COUNT];

    /// `Encode` in `T: Encode`.
    fn bound(&self) -> Path;

    /// Generates the derive implementation.
    fn derive_impl(
        &self,
        output: [TokenStream; ITEM_COUNT],
        ident: Ident,
        generics: Generics,
    ) -> TokenStream;

    fn field_attrs(
        &self,
        fields: &Fields,
        attrs: &BitcodeAttrs,
        bounds: &mut FieldBounds,
    ) -> Result<Vec<BitcodeAttrs>> {
        fields
            .iter()
            .map(|field| {
                let field_attrs = BitcodeAttrs::parse_field(&field.attrs, attrs)?;
                bounds.add_bound_type(field.clone(), &field_attrs, self.bound());
                Ok(field_attrs)
            })
            .collect()
    }

    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"),
                    );
                }