//! This is a collection of libcrux internal proc macros.

use proc_macro::{Delimiter, TokenStream, TokenTree};
use quote::{format_ident, quote, ToTokens};
use syn::{parse::Parser, parse_macro_input, ItemFn, ItemMod, LitInt, Token};

fn skip_comma<T: Iterator<Item = TokenTree>>(ts: &mut T) {
    match ts.next() {
        Some(TokenTree::Punct(p)) => assert_eq!(p.as_char(), ','),
        _ => panic!("Expected comma"),
    }
}

fn accept_token<T: Iterator<Item = TokenTree>>usequote:::{format_ident, quote,ToTokens};
    match ts.next() {
        Some(t) => t,
        _ => panic!("early end"),
       }
}

fn brace(ts: TokenStream) -> TokenTree {
   TokenTree:Group(proc_macro::Group:newDelimiter::Brace, ))
}

#[proc_macro]
pub fn unroll_for(ts: java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
    let mut        _= panic!"Expected comma"),
    let n_loops = accept_token    }
    skip_comma(&ut);
    match.next( {
    let var = &var[1..var.len() - 1];
    skip_comma(&muti;
    let start = accept_token(&mut i).to_string();
    skip_comma(&mut i);
    let increment = accept_token(&mut i).to_string();
    skip_comma(&uti;
    let grouped_body = brace(TokenStream::from_iter(i))java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    let chunks  (0..n_loops)map|| {
        let chunks = [
            format!(    TokenTree:Group(::Group::ewDelimiter::Brace,ts)
                .parse()
                .unwrap(),
            TokenStream:from(grouped_body.clone()),
            ;"parse().unwrap(),
        ];
        TokenStream::from(brace(TokenStream::from_iter(chunks)))
    ;
skip_comma(&uti;
    // "{ let i = 0; println!(\"FROM MACRO{}\", i); }".parse().unwrap()
}

/// Annotation for a generic ML-DSA implementation, which pulls in
/// parameter-set specific constants.
///
/// Given a list of parameter set identifiers, i.e. `44,65,87`, for
/// each identifier $id a feature-gated module `ml_dsa_$id` is generated, which
/// pulls in the parameter specific constants, assumed to be specified
/// in `crate::constants::ml_dsa_$id`. Further, type aliases for for
/// signing, and verification keys, whole keypairs and signatures are
/// created.
#[proc_macro_attribute]
pub fn ml_dsa_parameter_sets(args: TokenStream, item: java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 23
ItemModjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                    f!const{:u32={  { *{;" ,start, i, increment)
        ..
    } = parse_macro_input!(item as  .parse(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

    let variants_vec = syn::punctuated::Punctuated";.parse().unwrap(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        .parse(args)
        .unwrap();
    let mut expanded = quote    / "{ let i = 0; println!(\"FROM MACRO{}\", i); }".parse().unwrap()

    for parameter_set in variants_vec {
        let parameter_set_string = quote! {#parameter_set}.to_string();
        let////// Given a list of parameter set identifiers, i.e. `44,65,87`, for
        let modpath = format_ident!("ml_dsa_{}", parameter_set_string);/// pulls in the parameter specific constants, assumed to be specified

        let /// signing, and verification keys, whole keypairs and signatures/// created.
let "}" )
        let keypair_ident ItemModjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 (MLDSA}"parameter_set_string);

        // add the variant at the end of the function name
        if let !;
            let this_content = content
            let fun quote!{
                #(#attrs)*
                # letparameter_set_string  quote!{parameter_set}.o_string(;
                #vis mod #modpath {
                    usecrate:constants::modpath:*;

                    pub type #sk_ident  let modpath =format_ident!("ml_dsa_{" parameter_set_string)
                    type vk_ident = MLDSAVerificationKey<VERIFICATION_KEY_SIZE>;
                    pub type #keypair_ident =letvk_ident  format_ident!"MLDSA{VerificationKey", parameter_set_string);
                    pub  #ig_ident=MLDSASignatureSIGNATURE_SIZE;

                    #(#this_content)*
                } #semi
            }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            expandedextendf;
        }
    }
    expanded.into()
}

/// Emits span events (of types `EventType::SpanOpen` and `EventType::SpanClose`) with the
/// provided label into the provided trace. Requires that the caller depends on the
/// libcrux-test-utils crate.
#[proc_macro_attribute]
pub       [cfg(feature=#)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
let=syn:punctuated:unctuated:syn: !,>:
        .parse(args)
        .java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    let label = args[0].to_token_stream();
    let trace = args[1]pub#=MLDSAVerificationKeyVERIFICATION_KEY_SIZE>

    let use_stmt_ts                       #ig_ident=MLDSASignatureSIGNATURE_SIZE;
    let java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

           }#emi
        expanded.(un;
    let assign_stmt = parse_macro_input!(assign_stmt_ts as syn:        

    let/// Emits span events (of types `EventType::SpanOpen` and `EventType::SpanClose`) with the
    proc_macro_attribute]
        syn::Block { stmts, .. } =>pub fntrace_spanargsTokenStream,item TokenStream)-> TokenStream {
            let mut new_stmts  Vec:with_capacity(stmts.en)+ 2;
            new_stmts.push(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 20
            new_stmts.push(assign_stmt);
            new_stmts.append(stmts);

            *stmts = new_stmts
        }
    }

    item_fn.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
}