Implement combine_substructure helper about syn HOT 3 CLOSED

    fn eq(&self, __arg_0: &Foo<T>) -> bool {
        match *__arg_0 {
            Foo { foo: ref __self_1_0, bar: ref __self_1_1 } =>
            match *self {
                Foo { foo: ref __self_0_0, bar: ref __self_0_1 } =>
                true && (*__self_0_0) == (*__self_1_0) &&
                    (*__self_0_1) == (*__self_1_1),
            },
        }
    }

    fn eq(&self, __arg_0: &Foo<T>) -> bool {
        match *__arg_0 {
            Foo { foo: ref __binding_0, bar: ref __binding_1 } => {
                let __self_1_0 = __binding_0;
                let __self_1_1 = __binding_1;
                match *self {
                    Foo { foo: ref __binding_0, bar: ref __binding_1 } =>
                    true && (*__binding_0) == (*__self_1_0) &&
                        (*__binding_1) == (*__self_1_1),
                }
            }
        }
    }

fn derive_partialeq(input: TokenStream) -> TokenStream {
    let source = input.to_string();
    let mut ast = syn::parse_macro_input(&source).unwrap();
    // We need to copy the AST for the inner body, because match_substructs
    // takes a mutable reference. It's kinda gross, and optimized for the case
    // where we want to be able to remove attributes from within the callback.
    // I might change this in the future.
    let mut ast2 = ast.clone();

    let body = match_substructs(&mut ast, bind, |outer_bis| {
        let (renaming, outer_bis) = rename_bindings(outer_bis, "outer");
        let inner_body = match_substructs(&mut ast, bind, |inner_bis| {
            let mut zipped = outer_bis.into_iter().zip(inner_bis.into_iter());
            let eqs = zipped.map(|(x, y)| quote!((#x == #y)));
            quote!(true #(&& #eqs)*)
        })
        quote!{
            #renaming
            match *self { #inner_body }
        }
    }):

    let name = &ast.ident;
    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
    let result = quote! {
        #ast

        impl #impl_generics PartialEq for #name #ty_generics #where_clause {
            fn eq(&self, __arg_0: &Self) -> bool {
                match *__arg_0 { #body }
            }
        }
    };

    result.to_string().parse().unwrap()
}