Method enum_impl

bitcode_derive/src/decode.rs:84–215

(
        self,
        variant_count: usize,
        pattern: impl Fn(usize) -> TokenStream,
        inner: impl Fn(Self, usize) -> TokenStream,
    )

    }

    fn enum_impl(
        self,
        variant_count: usize,
        pattern: impl Fn(usize) -> TokenStream,
        inner: impl Fn(Self, usize) -> TokenStream,
    ) -> TokenStream {
        // if variant_count is 0 or 1 variants don't have to be decoded.
        let decode_variants = variant_count > 1;
        let never = variant_count == 0;

        match self {
            Self::Type => {
                let de = de_lifetime();
                let inners: TokenStream = (0..variant_count).map(|i| inner(self, i)).collect();
                let variants = decode_variants
                    .then(|| {
                        let private = private();
                        let c_style = inners.is_empty();
                        quote! { variants: #private::VariantDecoder<#de, #variant_count, #c_style>, }
                    })
                    .unwrap_or_default();
                quote! {
                    #variants
                    #inners
                }
            }
            Self::Default => {
                let variants = decode_variants
                    .then(|| quote! { variants: Default::default(), })
                    .unwrap_or_default();
                let inners: TokenStream = (0..variant_count).map(|i| inner(self, i)).collect();
                quote! {
                    #variants
                    #inners
                }
            }
            Self::Populate => {
                if never {
                    let private = private();
                    return quote! {
                        if __length != 0 {
                            return #private::invalid_enum_variant();
                        }
                    };
                }

                let variants = decode_variants
                    .then(|| {
                        quote! { self.variants.populate(input, __length)?; }
                    })
                    .unwrap_or_default();
                let inners: TokenStream = (0..variant_count)
                    .map(|i| {
                        let inner = inner(self, i);
                        if inner.is_empty() {
                            quote! {}
                        } else {
                            let i = variant_index(i);