Method derive_impl

bitcode_derive/src/encode.rs:232–301

(
        &self,
        output: [TokenStream; Item::COUNT],
        ident: Ident,
        mut generics: Generics,
    )

    }

    fn derive_impl(
        &self,
        output: [TokenStream; Item::COUNT],
        ident: Ident,
        mut generics: Generics,
    ) -> TokenStream {
        let input_generics = generics.clone();
        let (impl_generics, input_generics, where_clause) = input_generics.split_for_impl();
        let input_ty = quote! { #ident #input_generics };

        // Encoder can't contain any lifetimes from input (which would limit reuse of encoder).
        remove_lifetimes(&mut generics);
        let (encoder_impl_generics, encoder_generics, encoder_where_clause) =
            generics.split_for_impl();

        let [type_body, default_body, encode_body, encode_vectored_body, collect_into_body, reserve_body] =
            output;
        let encoder_ident = Ident::new(&format!("{ident}Encoder"), Span::call_site());
        let encoder_ty = quote! { #encoder_ident #encoder_generics };
        let private = private();

        quote! {
            const _: () = {
                impl #impl_generics #private::Encode for #input_ty #where_clause {
                    type Encoder = #encoder_ty;
                }

                #[allow(non_snake_case)]
                pub struct #encoder_ident #encoder_impl_generics #encoder_where_clause {
                    #type_body
                }

                // Avoids bounding #impl_generics: Default.
                impl #encoder_impl_generics std::default::Default for #encoder_ty #encoder_where_clause {
                    fn default() -> Self {
                        Self {
                            #default_body
                        }
                    }
                }

                impl #impl_generics #private::Encoder<#input_ty> for #encoder_ty #where_clause {
                    #[cfg_attr(not(debug_assertions), inline(always))]
                    fn encode(&mut self, v: &#input_ty) {
                        #[allow(unused_imports)]
                        use #private::Buffer as _;
                        #encode_body
                    }

                    // #[cfg_attr(not(debug_assertions), inline(always))]
                    // #[inline(never)]
                    fn encode_vectored<'__v>(&mut self, i: impl Iterator<Item = &'__v #input_ty> + Clone) where #input_ty: '__v {
                        #[allow(unused_imports)]
                        use #private::Buffer as _;
                        #encode_vectored_body
                    }
                }