use proc_macro::TokenStream;

#[proc_macro]
pub fn repro(item: TokenStream) -> TokenStream {
    eprintln!("{item:#?}");
    venial::parse_declaration(item.into()).expect("Won't even get here");
    Default::default()
}

#[proc_macro]
pub fn non_repro_syn(input: TokenStream) -> TokenStream {
    syn::parse_macro_input!(input as syn::DeriveInput);
    Default::default()
}

#[proc_macro]
pub fn non_repro_normalize(item: TokenStream) -> TokenStream {
    let item = normalize(item.into());
    eprintln!("{item:#?}");
    venial::parse_declaration(item).expect("Won't even get here");
    Default::default()
}

fn normalize(ts: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
    ts.into_iter()
        .flat_map(|tt| match tt {
            proc_macro2::TokenTree::Group(g) if g.delimiter() == proc_macro2::Delimiter::None => {
                normalize(g.stream())
            }
            proc_macro2::TokenTree::Group(group) => {
                let inner = normalize(group.stream());
                let mut ngroup = proc_macro2::Group::new(group.delimiter(), inner);
                ngroup.set_span(group.span());
                [proc_macro2::TokenTree::Group(ngroup)]
                    .into_iter()
                    .collect()
            }
            x => [x].into_iter().collect(),
        })
        .collect()
}