Method derive_impl

bitcode_derive/src/decode.rs:229–321

(
        &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 (_, input_generics, _) = input_generics.split_for_impl();
        let input_ty = quote! { #ident #input_generics };

        // Add 'de lifetime after isolating input_generics.
        let de = de_lifetime();
        let de_where_predicate = WherePredicate::Lifetime(PredicateLifetime {
            lifetime: de.clone(),
            colon_token: parse_quote!(:),
            bounds: generics
                .params
                .iter()
                .filter_map(|p| {
                    if let GenericParam::Lifetime(p) = p {
                        Some(p.lifetime.clone())
                    } else {
                        None
                    }
                })
                .collect(),
        });

        // Push de_param after bounding 'de: 'a.
        let de_param = GenericParam::Lifetime(LifetimeParam::new(de.clone()));
        generics.params.push(de_param.clone());
        generics
            .make_where_clause()
            .predicates
            .push(de_where_predicate);

        let combined_generics = generics.clone();
        let (impl_generics, _, where_clause) = combined_generics.split_for_impl();

        // Decoder can't contain any lifetimes from input (which would limit reuse of decoder).
        remove_lifetimes(&mut generics);
        generics.params.push(de_param); // Re-add de_param since remove_lifetimes removed it.
        let (decoder_impl_generics, decoder_generics, decoder_where_clause) =
            generics.split_for_impl();

        let [mut type_body, mut default_body, populate_body, decode_in_place_body] = output;
        if type_body.is_empty() {
            type_body = quote! { __spooky: std::marker::PhantomData<&#de ()>, };
        }
        if default_body.is_empty() {
            default_body = quote! { __spooky: Default::default(), };
        }

        let decoder_ident = Ident::new(&format!("{ident}Decoder"), Span::call_site());
        let decoder_ty = quote! { #decoder_ident #decoder_generics };
        let private = private();

        quote! {