Files

aho_corasick

packed

teddy

compile.rsmod.rsruntime.rs

api.rsmod.rspattern.rsrabinkarp.rsvector.rs

ahocorasick.rsautomaton.rsbuffer.rsbyte_frequencies.rsclasses.rsdfa.rserror.rslib.rsnfa.rsprefilter.rsstate_id.rs

anyhow

backtrace.rschain.rscontext.rserror.rsfmt.rskind.rslib.rsmacros.rswrapper.rs

drone_config

config.rsformat.rslib.rs

drone_core

bitfield

bits.rsmod.rs

ffi

c_str.rsc_string.rslibc.rsmod.rs

fib

chain.rsclosure.rsfuture.rsgenerator.rsmod.rsstream_pulse.rsstream_ring.rs

heap

allocator.rsmod.rspool.rs

io

mod.rsread.rsseek.rswrite.rs

log

macros.rsmod.rsport.rs

reg

field.rsmarker.rsmod.rsprelude.rstag.rs

sync

spsc

oneshot

mod.rsreceiver.rssender.rs

pulse

mod.rsreceiver.rssender.rs

ring

mod.rsreceiver.rssender.rs

mod.rs

mod.rsmutex.rsrwlock.rs

thr

mod.rsprelude.rs

inventory.rslang_items.rslib.rsmem.rsperiph.rsprelude.rsproc_loop.rstoken.rs

drone_core_macros

bitfield.rsconfig_override.rsheap.rslib.rslog_baud_rate.rsperiph.rsperiph_map.rsperiph_singular.rsreg.rsreg_assert_taken.rsreg_tokens.rsreg_tokens_inner.rssimple_token.rssimple_tokens.rsstatic_tokens.rsthr.rs

drone_ctypes

lib.rs

drone_macros_core

cfg_cond.rslib.rsmacros.rsunkeywordize.rs

futures

lib.rs

futures_channel

lib.rslock.rsoneshot.rs

futures_core

task

__internal

atomic_waker.rsmod.rs

mod.rspoll.rs

future.rslib.rsstream.rs

futures_io

lib.rs

futures_macro

join.rslib.rsselect.rs

futures_sink

lib.rs

futures_task

arc_wake.rsfuture_obj.rslib.rsnoop_waker.rsspawn.rswaker.rswaker_ref.rs

futures_util

async_await

join_mod.rsmod.rspending.rspoll.rsselect_mod.rs

future

future

flatten.rsfuse.rsmap.rsmod.rs

try_future

into_future.rsmod.rstry_flatten.rstry_flatten_err.rs

abortable.rseither.rsjoin.rsjoin_all.rslazy.rsmaybe_done.rsmod.rsoption.rspending.rspoll_fn.rsready.rsselect.rsselect_all.rsselect_ok.rstry_join.rstry_join_all.rstry_maybe_done.rstry_select.rs

lock

bilock.rsmod.rs

sink

buffer.rsclose.rsdrain.rserr_into.rsfanout.rsflush.rsmap_err.rsmod.rssend.rssend_all.rswith.rswith_flat_map.rs

stream

futures_unordered

abort.rsiter.rsmod.rsready_to_run_queue.rstask.rs

stream

buffer_unordered.rsbuffered.rschain.rschunks.rscollect.rsconcat.rscycle.rsenumerate.rsfilter.rsfilter_map.rsflatten.rsfold.rsfor_each.rsfor_each_concurrent.rsforward.rsfuse.rsinto_future.rsmap.rsmod.rsnext.rspeek.rsready_chunks.rsscan.rsselect_next_some.rsskip.rsskip_while.rssplit.rstake.rstake_until.rstake_while.rsthen.rszip.rs

try_stream

and_then.rsinto_stream.rsmod.rsor_else.rstry_buffer_unordered.rstry_buffered.rstry_collect.rstry_concat.rstry_filter.rstry_filter_map.rstry_flatten.rstry_fold.rstry_for_each.rstry_for_each_concurrent.rstry_next.rstry_skip_while.rstry_take_while.rstry_unfold.rs

empty.rsfutures_ordered.rsiter.rsmod.rsonce.rspending.rspoll_fn.rsrepeat.rsselect.rsselect_all.rsunfold.rs

task

mod.rsspawn.rs

fns.rslib.rsnever.rs

if_chain

lib.rs

inflector

cases

camelcase

mod.rs

case

mod.rs

classcase

mod.rs

kebabcase

mod.rs

pascalcase

mod.rs

screamingsnakecase

mod.rs

sentencecase

mod.rs

snakecase

mod.rs

tablecase

mod.rs

titlecase

mod.rs

traincase

mod.rs

mod.rs

numbers

deordinalize

mod.rs

ordinalize

mod.rs

mod.rs

string

constants

mod.rs

deconstantize

mod.rs

demodulize

mod.rs

pluralize

mod.rs

singularize

mod.rs

mod.rs

suffix

foreignkey

mod.rs

mod.rs

lib.rs

lazy_static

inline_lazy.rslib.rs

memchr

x86

avx.rsmod.rssse2.rs

fallback.rsiter.rslib.rsnaive.rs

pin_project

lib.rs

pin_project_internal

pin_project

args.rsattribute.rsderive.rsmod.rs

lib.rspinned_drop.rsutils.rs

pin_utils

lib.rsprojection.rsstack_pin.rs

proc_macro2

detection.rsfallback.rslib.rsmarker.rsparse.rswrapper.rs

proc_macro_hack

error.rsiter.rslib.rsparse.rsquote.rs

proc_macro_nested

lib.rs

quote

ext.rsformat.rsident_fragment.rslib.rsruntime.rsspanned.rsto_tokens.rs

regex

literal

imp.rsmod.rs

backtrack.rscache.rscompile.rsdfa.rserror.rsexec.rsexpand.rsfind_byte.rsfreqs.rsinput.rslib.rspikevm.rsprog.rsre_builder.rsre_bytes.rsre_set.rsre_trait.rsre_unicode.rssparse.rsutf8.rs

regex_syntax

ast

mod.rsparse.rsprint.rsvisitor.rs

hir

literal

mod.rs

interval.rsmod.rsprint.rstranslate.rsvisitor.rs

unicode_tables

age.rscase_folding_simple.rsgeneral_category.rsgrapheme_cluster_break.rsmod.rsperl_word.rsproperty_bool.rsproperty_names.rsproperty_values.rsscript.rsscript_extension.rssentence_break.rsword_break.rs

either.rserror.rslib.rsparser.rsunicode.rsutf8.rs

serde

de

from_primitive.rsignored_any.rsimpls.rsmod.rsutf8.rsvalue.rs

private

de.rsmacros.rsmod.rsser.rs

ser

fmt.rsimpls.rsimpossible.rsmod.rs

export.rsinteger128.rslib.rsmacros.rs

serde_derive

internals

ast.rsattr.rscase.rscheck.rsctxt.rsmod.rssymbol.rs

bound.rsde.rsdummy.rsfragment.rslib.rspretend.rsser.rstry.rs

syn

gen

clone.rsdebug.rseq.rsgen_helper.rshash.rsvisit.rsvisit_mut.rs

attr.rsawait.rsbigint.rsbuffer.rscustom_keyword.rscustom_punctuation.rsdata.rsderive.rsdiscouraged.rserror.rsexport.rsexpr.rsext.rsfile.rsgenerics.rsgroup.rsident.rsitem.rslib.rslifetime.rslit.rslookahead.rsmac.rsmacros.rsop.rsparse.rsparse_macro_input.rsparse_quote.rspat.rspath.rsprint.rspunctuated.rsreserved.rssealed.rsspan.rsspanned.rsstmt.rsthread.rstoken.rstt.rsty.rsverbatim.rswhitespace.rs

thread_local

cached.rslib.rsthread_id.rsunreachable.rs

toml

datetime.rsde.rslib.rsmacros.rsmap.rsser.rsspanned.rstokens.rsvalue.rs

typenum

array.rsbit.rsint.rslib.rsmarker_traits.rsoperator_aliases.rsprivate.rstype_operators.rsuint.rs

unicode_xid

lib.rstables.rs

>

use drone_macros_core::{parse_error, parse_ident, unkeywordize, CfgCond, CfgCondExt};
use inflector::Inflector;
use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{
    braced, parenthesized,
    parse::{Parse, ParseStream, Result},
    parse_macro_input, token, Attribute, Ident, ImplItem, Path, Token,
};

const MACRO_PREFIX: &str = "periph_";
const TRAIT_SUFFIX: &str = "Map";

struct Input {
    macro_attrs: Vec<Attribute>,
    macro_ident: Ident,
    struct_attrs: Vec<Attribute>,
    struct_ident: Ident,
    trait_ident: Ident,
    items: Vec<ImplItem>,
    root_path: Path,
    macro_root_path: Option<Path>,
    blocks: Vec<Block>,
}

struct Block {
    ident: Ident,
    path: Option<Ident>,
    regs: Vec<Reg>,
}

struct Reg {
    features: CfgCond,
    ident: Ident,
    variants: Vec<Variant>,
}

#[derive(Default)]
struct Variant {
    ident: Option<Ident>,
    path: Option<Ident>,
    variant: Option<(Ident, Ident)>,
    traits: Vec<Ident>,
    fields: Vec<Field>,
}

struct Field {
    features: CfgCond,
    ident: Ident,
    path: Option<Ident>,
    traits: Vec<Ident>,
}

impl Parse for Input {
    fn parse(input: ParseStream<'_>) -> Result<Self> {
        let macro_attrs = input.call(Attribute::parse_outer)?;
        input.parse::<Token![pub]>()?;
        input.parse::<Token![macro]>()?;
        let macro_ident = input.parse::<Ident>()?;
        if !macro_ident.to_string().starts_with(MACRO_PREFIX) {
            return Err(
                input.error(format!("Expected an ident which starts with `{}`", MACRO_PREFIX))
            );
        }
        input.parse::<Token![;]>()?;
        let struct_attrs = input.call(Attribute::parse_outer)?;
        input.parse::<Token![pub]>()?;
        input.parse::<Token![struct]>()?;
        let struct_ident = input.parse()?;
        input.parse::<Token![;]>()?;
        input.parse::<Token![impl]>()?;
        let trait_ident = input.parse()?;
        input.parse::<Token![for]>()?;
        parse_ident!(input, struct_ident);
        let content;
        braced!(content in input);
        let mut items = Vec::new();
        while !content.is_empty() {
            items.push(content.parse()?);
        }
        let root_path = input.parse()?;
        input.parse::<Token![;]>()?;
        input.parse::<Token![crate]>()?;
        let macro_root_path = if input.peek(Token![;]) {
            input.parse::<Token![;]>()?;
            None
        } else {
            let path = input.parse()?;
            input.parse::<Token![;]>()?;
            Some(path)
        };
        let mut blocks = Vec::new();
        while !input.is_empty() {
            blocks.push(input.parse()?);
        }
        Ok(Self {
            macro_attrs,
            macro_ident,
            struct_attrs,
            struct_ident,
            trait_ident,
            items,
            root_path,
            macro_root_path,
            blocks,
        })
    }
}

impl Parse for Block {
    fn parse(input: ParseStream<'_>) -> Result<Self> {
        let ident = input.parse()?;
        let content;
        braced!(content in input);
        let path = if content.peek2(Token![;]) {
            let path = content.parse()?;
            content.parse::<Token![;]>()?;
            Some(path)
        } else {
            None
        };
        let mut regs = Vec::new();
        while !content.is_empty() {
            regs.push(content.parse()?);
        }
        Ok(Self { ident, path, regs })
    }
}

impl Parse for Reg {
    fn parse(input: ParseStream<'_>) -> Result<Self> {
        let features = input.parse()?;
        let ident = input.parse()?;
        let content;
        braced!(content in input);
        let mut variants = Vec::new();
        while !content.is_empty() {
            variants.push(content.parse()?);
        }
        if variants.is_empty() {
            variants.push(Variant::default());
        }
        Ok(Self { features, ident, variants })
    }
}

impl Parse for Variant {
    fn parse(input: ParseStream<'_>) -> Result<Self> {
        let ident =
            if input.parse::<Option<Token![@]>>()?.is_some() { Some(input.parse()?) } else { None };
        let mut path = None;
        let mut variant = None;
        let mut traits = Vec::new();
        let mut fields = Vec::new();
        let is_end = || !(input.is_empty() || (ident.is_some() && input.peek(Token![@])));
        if is_end() {
            path = Some(input.parse()?);
            if input.peek(token::Paren) {
                let content;
                parenthesized!(content in input);
                variant = Some((content.parse()?, content.parse()?));
            }
            while !input.peek(Token![;]) {
                traits.push(input.parse()?);
            }
            input.parse::<Token![;]>()?;
            while is_end() {
                fields.push(input.parse()?);
            }
        };
        Ok(Self { ident, path, variant, traits, fields })
    }
}

impl Parse for Field {
    fn parse(input: ParseStream<'_>) -> Result<Self> {
        let features = input.parse()?;
        let ident = input.parse()?;
        let content;
        braced!(content in input);
        let mut traits = Vec::new();
        let path = if content.is_empty() {
            None
        } else {
            let path = content.parse()?;
            while !content.is_empty() {
                traits.push(content.parse()?);
            }
            Some(path)
        };
        Ok(Self { features, ident, path, traits })
    }
}

#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
pub fn proc_macro(input: TokenStream) -> TokenStream {
    let Input {
        macro_attrs: periph_macro_attrs,
        macro_ident: periph_macro,
        struct_attrs: periph_ty_attrs,
        struct_ident: periph_ty,
        trait_ident: periph_trait,
        items: periph_items,
        root_path,
        macro_root_path,
        blocks,
    } = &parse_macro_input!(input);
    let core_urt = quote!(::drone_core::reg::tag::Urt);
    let core_srt = quote!(::drone_core::reg::tag::Srt);
    let core_crt = quote!(::drone_core::reg::tag::Crt);

    let mut tokens = Vec::new();
    let mut macro_tokens = Vec::new();
    for Block { ident: block_ident, path: block_path, regs } in blocks {
        let block_snk = block_ident.to_string().to_snake_case();
        let block_psc = block_ident.to_string().to_pascal_case();
        let block_path = block_path.as_ref().unwrap_or(block_ident);
        let block_path_snk = format_ident!("{}", block_path.to_string().to_snake_case());
        let block_path_ident =
            format_ident!("{}", unkeywordize(block_path_snk.to_string().as_str()));
        for Reg { features: reg_features, ident: reg_ident, variants } in regs {
            let reg_snk = reg_ident.to_string().to_snake_case();
            let reg_psc = reg_ident.to_string().to_pascal_case();
            for (variant_i, variant) in variants.iter().enumerate() {
                let Variant { ident: variant_ident, path: var_path, variant, traits, fields } =
                    variant;
                let (var_snk, var_psc) = if let Some(variant_ident) = variant_ident {
                    (
                        format!("{}_{}", reg_snk, variant_ident.to_string().to_snake_case()),
                        format!("{}{}", reg_psc, variant_ident.to_string().to_pascal_case()),
                    )
                } else {
                    (reg_snk.clone(), reg_psc.clone())
                };
                let var_path_snk = var_path
                    .as_ref()
                    .map(|ident| format_ident!("{}", ident.to_string().to_snake_case()));
                let var_path_ident = var_path_snk
                    .as_ref()
                    .map(|ident| format_ident!("{}", unkeywordize(ident.to_string().as_str())));
                let block_var_snk = format_ident!("{}_{}", block_snk, var_snk);
                let block_var_path_snk = var_path_snk
                    .as_ref()
                    .map(|var_path_snk| format_ident!("{}_{}", block_path_snk, var_path_snk));
                let reg_trait = format_ident!("{}{}", block_psc, var_psc);
                let reg_trait_opt = format_ident!("{}{}Opt", block_psc, var_psc);
                let reg_trait_ext = format_ident!("{}{}Ext", block_psc, var_psc);
                let val = format_ident!("{}{}Val", block_psc, var_psc);
                let u_reg = format_ident!("U{}{}", block_psc, var_psc);
                let s_reg = format_ident!("S{}{}", block_psc, var_psc);
                let c_reg = format_ident!("C{}{}", block_psc, var_psc);
                let u_reg_opt = format_ident!("U{}{}Opt", block_psc, var_psc);
                let s_reg_opt = format_ident!("S{}{}Opt", block_psc, var_psc);
                let c_reg_opt = format_ident!("C{}{}Opt", block_psc, var_psc);
                let u_fields = format_ident!("U{}{}Fields", block_psc, var_psc);
                let s_fields = format_ident!("S{}{}Fields", block_psc, var_psc);
                let c_fields = format_ident!("C{}{}Fields", block_psc, var_psc);
                let reg_attrs = reg_features.attrs();
                let (mut reg_shared, mut reg_option) = (false, false);
                for ident in traits {
                    if ident == "Shared" {
                        reg_shared = true;
                    } else if ident == "Option" {
                        reg_option = true;
                    } else {
                        parse_error!("Unknown option `{}`", ident);
                    }
                }
                if reg_shared && reg_option {
                    parse_error!("`Option` and `Shared` can't be used simultaneously");
                }
                if variants.len() > 1 && reg_shared {
                    parse_error!("`Shared` can't be used with multiple variants");
                }
                if reg_option
                    && !variants
                        .iter()
                        .all(|v| v.path.is_none() || v.traits.iter().any(|t| t == "Option"))
                {
                    parse_error!("`Option` should be defined for all variants");
                }
                let reg_root = &quote!(#root_path::#block_path_ident::#var_path_ident);
                let mut reg_fields_tokens = Vec::new();
                let mut fields_reg_tokens = Vec::new();
                let mut fields_tokens = Vec::new();
                let mut u_tokens = Vec::new();
                let mut s_tokens = Vec::new();
                let mut c_tokens = Vec::new();
                for Field {
                    features: field_features,
                    ident: field_ident,
                    path: field_path,
                    traits,
                } in fields
                {
                    let field_path_psc = field_path
                        .as_ref()
                        .map(|ident| format_ident!("{}", ident.to_string().to_pascal_case()));
                    let field_path_ident = field_path.as_ref().map(|ident| {
                        format_ident!(
                            "{}",
                            unkeywordize(ident.to_string().to_snake_case().as_str())
                        )
                    });
                    let field_snk = field_ident.to_string().to_snake_case();
                    let field_psc = field_ident.to_string().to_pascal_case();
                    let field_ident = format_ident!("{}", unkeywordize(field_snk.clone().as_str()));
                    let block_reg_field_snk =
                        format_ident!("{}_{}_{}", block_snk, var_snk, field_snk);
                    let field_trait = format_ident!("{}{}{}", block_psc, var_psc, field_psc);
                    let field_trait_opt = format_ident!("{}{}{}Opt", block_psc, var_psc, field_psc);
                    let field_trait_ext = format_ident!("{}{}{}Ext", block_psc, var_psc, field_psc);
                    let u_field = format_ident!("U{}{}{}", block_psc, var_psc, field_psc);
                    let s_field = format_ident!("S{}{}{}", block_psc, var_psc, field_psc);
                    let c_field = format_ident!("C{}{}{}", block_psc, var_psc, field_psc);
                    let u_field_opt = format_ident!("U{}{}{}Opt", block_psc, var_psc, field_psc);
                    let s_field_opt = format_ident!("S{}{}{}Opt", block_psc, var_psc, field_psc);
                    let c_field_opt = format_ident!("C{}{}{}Opt", block_psc, var_psc, field_psc);
                    let mut field_option = false;
                    for ident in traits {
                        if ident == "Option" {
                            field_option = true;
                        } else {
                            parse_error!("Unknown option `{}`", ident);
                        }
                    }
                    let mut features = CfgCond::default();
                    features.add_clause(&reg_features);
                    features.add_clause(&field_features);
                    let field_attrs = features.attrs();
                    let struct_attrs = field_features.attrs();
                    if field_path.is_none() {
                        if reg_shared {
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait_opt for #periph_ty {
                                    type #u_field_opt = ();
                                    type #s_field_opt = ();
                                    type #c_field_opt = ();
                                }
                            });
                            macro_tokens.push((features, quote!(#block_reg_field_snk: ())));
                        } else {
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait_opt<#periph_ty> for #periph_ty {
                                    type #u_field_opt = ();
                                    type #s_field_opt = ();
                                    type #c_field_opt = ();
                                }
                            });
                        }
                        u_tokens.push(quote! {
                            #struct_attrs
                            #[inline]
                            fn #field_ident(&self) -> &() { &() }
                        });
                        s_tokens.push(quote! {
                            #struct_attrs
                            #[inline]
                            fn #field_ident(&self) -> &() { &() }
                        });
                        c_tokens.push(quote! {
                            #struct_attrs
                            #[inline]
                            fn #field_ident(&self) -> &() { &() }
                        });
                        fields_tokens.push(quote! {
                            #struct_attrs
                            #field_ident: ()
                        });
                    } else if reg_shared {
                        if field_option {
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait_opt for #periph_ty {
                                    type #u_field_opt = #reg_root::#field_path_psc<#core_urt>;
                                    type #s_field_opt = #reg_root::#field_path_psc<#core_srt>;
                                    type #c_field_opt = #reg_root::#field_path_psc<#core_crt>;
                                }
                            });
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait_ext for #periph_ty {
                                    type #u_field = #reg_root::#field_path_psc<#core_urt>;
                                    type #s_field = #reg_root::#field_path_psc<#core_srt>;
                                    type #c_field = #reg_root::#field_path_psc<#core_crt>;
                                }
                            });
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait for #periph_ty {}
                            });
                        } else {
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait for #periph_ty {
                                    type #u_field = #reg_root::#field_path_psc<#core_urt>;
                                    type #s_field = #reg_root::#field_path_psc<#core_srt>;
                                    type #c_field = #reg_root::#field_path_psc<#core_crt>;
                                }
                            });
                        }
                        macro_tokens.push((features, quote! {
                            #block_reg_field_snk: $reg.#block_var_path_snk.#field_path_ident
                        }));
                    } else {
                        if field_option {
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait_opt<#periph_ty> for #periph_ty {
                                    type #u_field_opt = #reg_root::#field_path_psc<#core_urt>;
                                    type #s_field_opt = #reg_root::#field_path_psc<#core_srt>;
                                    type #c_field_opt = #reg_root::#field_path_psc<#core_crt>;
                                }
                            });
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait_ext<#periph_ty> for #periph_ty {
                                    type #u_field = #reg_root::#field_path_psc<#core_urt>;
                                    type #s_field = #reg_root::#field_path_psc<#core_srt>;
                                    type #c_field = #reg_root::#field_path_psc<#core_crt>;
                                }
                            });
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait for #periph_ty {}
                            });
                        } else {
                            tokens.push(quote! {
                                #field_attrs
                                impl #field_trait<#periph_ty> for #periph_ty {
                                    type #u_field = #reg_root::#field_path_psc<#core_urt>;
                                    type #s_field = #reg_root::#field_path_psc<#core_srt>;
                                    type #c_field = #reg_root::#field_path_psc<#core_crt>;
                                }
                            });
                        }
                        u_tokens.push(quote! {
                            #struct_attrs
                            #[inline]
                            fn #field_ident(&self) -> &#reg_root::#field_path_psc<#core_urt> {
                                &self.#field_path_ident
                            }
                        });
                        s_tokens.push(quote! {
                            #struct_attrs
                            #[inline]
                            fn #field_ident(&self) -> &#reg_root::#field_path_psc<#core_srt> {
                                &self.#field_path_ident
                            }
                        });
                        c_tokens.push(quote! {
                            #struct_attrs
                            #[inline]
                            fn #field_ident(&self) -> &#reg_root::#field_path_psc<#core_crt> {
                                &self.#field_path_ident
                            }
                        });
                        fields_reg_tokens.push(quote! {
                            #struct_attrs
                            #field_ident: #field_path_ident
                        });
                        reg_fields_tokens.push(quote! {
                            #struct_attrs
                            #field_path_ident
                        });
                    }
                }
                let reg_fields_tokens = &reg_fields_tokens;
                let fields_reg_tokens = &fields_reg_tokens;
                let fields_tokens = &fields_tokens;
                if var_path.is_none() {
                    tokens.push(quote! {
                        #reg_attrs
                        impl #reg_trait_opt for #periph_ty {
                            type #u_reg_opt = ();
                            type #s_reg_opt = ();
                            type #c_reg_opt = ();
                        }
                    });
                    if !reg_shared && variant_i == 0 {
                        macro_tokens.push((reg_features.clone(), quote!(#block_var_snk: ())));
                    }
                } else if reg_shared {
                    if fields.iter().any(|field| field.path.is_some()) {
                        tokens.push(quote! {
                            #reg_attrs
                            impl #reg_trait for #periph_ty {
                                type #val = #reg_root::Val;
                                type #u_reg = #reg_root::Reg<#core_urt>;
                                type #s_reg = #reg_root::Reg<#core_srt>;
                                type #c_reg = #reg_root::Reg<#core_crt>;
                            }
                        });
                    }
                } else {
                    if reg_option {
                        tokens.push(quote! {
                            #reg_attrs
                            impl #reg_trait_opt for #periph_ty {
                                type #u_reg_opt = #reg_root::Reg<#core_urt>;
                                type #s_reg_opt = #reg_root::Reg<#core_srt>;
                                type #c_reg_opt = #reg_root::Reg<#core_crt>;
                            }
                        });
                        tokens.push(quote! {
                            #reg_attrs
                            impl #reg_trait_ext<#periph_ty> for #periph_ty {
                                type #val = #reg_root::Val;
                                type #u_reg = #reg_root::Reg<#core_urt>;
                                type #s_reg = #reg_root::Reg<#core_srt>;
                                type #c_reg = #reg_root::Reg<#core_crt>;
                            }
                        });
                        tokens.push(quote! {
                            #reg_attrs
                            impl #reg_trait for #periph_ty {}
                        });
                    } else {
                        tokens.push(quote! {
                            #reg_attrs
                            impl #reg_trait<#periph_ty> for #periph_ty {
                                type #val = #reg_root::Val;
                                type #u_reg = #reg_root::Reg<#core_urt>;
                                type #s_reg = #reg_root::Reg<#core_srt>;
                                type #c_reg = #reg_root::Reg<#core_crt>;
                            }
                        });
                    }
                    for (variant_j, variant) in variants.iter().enumerate() {
                        if variant_i == variant_j {
                            continue;
                        }
                        let var_snk = variant.ident.as_ref().unwrap().to_string().to_snake_case();
                        let var_path_ident = format_ident!(
                            "{}",
                            unkeywordize(
                                variant.path.as_ref().unwrap().to_string().to_snake_case()
                            )
                        );
                        let var_root = &quote!(#root_path::#block_path_ident::#var_path_ident);
                        let into_variant = format_ident!("into_{}", var_snk);
                        let reg_into_variant =
                            format_ident!("into_{}_{}", block_path_ident, var_path_ident);
                        u_tokens.push(quote! {
                            #[inline]
                            fn #into_variant(self) -> #var_root::Reg<#core_urt> {
                                self.#reg_into_variant()
                            }
                        });
                        s_tokens.push(quote! {
                            #[inline]
                            fn #into_variant(self) -> #var_root::Reg<#core_srt> {
                                self.#reg_into_variant()
                            }
                        });
                        c_tokens.push(quote! {
                            #[inline]
                            fn #into_variant(self) -> #var_root::Reg<#core_crt> {
                                self.#reg_into_variant()
                            }
                        });
                    }
                    tokens.push(quote! {
                        #reg_attrs
                        impl #u_reg<#periph_ty> for #reg_root::Reg<#core_urt> {
                            #[inline]
                            fn from_fields(map: #u_fields<#periph_ty>) -> Self {
                                let #u_fields {
                                    #(#fields_reg_tokens,)*
                                    #(#fields_tokens,)*
                                } = map;
                                Self { #(#reg_fields_tokens),* }
                            }
                            #[inline]
                            fn into_fields(self) -> #u_fields<#periph_ty> {
                                let Self { #(#reg_fields_tokens),* } = self;
                                #u_fields {
                                    #(#fields_reg_tokens,)*
                                    #(#fields_tokens,)*
                                }
                            }
                            #(#u_tokens)*
                        }
                    });
                    tokens.push(quote! {
                        #reg_attrs
                        impl #s_reg<#periph_ty> for #reg_root::Reg<#core_srt> {
                            #[inline]
                            fn from_fields(map: #s_fields<#periph_ty>) -> Self {
                                let #s_fields {
                                    #(#fields_reg_tokens,)*
                                    #(#fields_tokens,)*
                                } = map;
                                Self { #(#reg_fields_tokens),* }
                            }
                            #[inline]
                            fn into_fields(self) -> #s_fields<#periph_ty> {
                                let Self { #(#reg_fields_tokens),* } = self;
                                #s_fields {
                                    #(#fields_reg_tokens,)*
                                    #(#fields_tokens,)*
                                }
                            }
                            #(#s_tokens)*
                        }
                    });
                    tokens.push(quote! {
                        #reg_attrs
                        impl #c_reg<#periph_ty> for #reg_root::Reg<#core_crt> {
                            #[inline]
                            fn from_fields(map: #c_fields<#periph_ty>) -> Self {
                                let #c_fields {
                                    #(#fields_reg_tokens,)*
                                    #(#fields_tokens,)*
                                } = map;
                                Self { #(#reg_fields_tokens),* }
                            }
                            #[inline]
                            fn into_fields(self) -> #c_fields<#periph_ty> {
                                let Self { #(#reg_fields_tokens),* } = self;
                                #c_fields {
                                    #(#fields_reg_tokens,)*
                                    #(#fields_tokens,)*
                                }
                            }
                            #(#c_tokens)*
                        }
                    });
                    if variant_i == 0 {
                        let macro_token =
                            if let Some((from_block_ident, from_var_path_ident)) = variant {
                                let from_variant = format_ident!(
                                    "{}_{}",
                                    from_block_ident.to_string().to_snake_case(),
                                    from_var_path_ident.to_string().to_snake_case()
                                );
                                let into_variant = var_path_snk.as_ref().map(|var_path_snk| {
                                    format_ident!("into_{}_{}", block_path_snk, var_path_snk)
                                });
                                quote!(#block_var_snk: $reg.#from_variant.#into_variant())
                            } else {
                                quote!(#block_var_snk: $reg.#block_var_path_snk)
                            };
                        macro_tokens.push((reg_features.clone(), macro_token));
                    }
                }
            }
        }
    }
    let mut periph_name_psc = periph_trait.to_string();
    periph_name_psc.truncate(periph_name_psc.len() - TRAIT_SUFFIX.len());
    let periph_struct = format_ident!("{}Periph", periph_name_psc);
    for (features, macro_tokens) in macro_tokens.as_slice().transpose() {
        let attrs = features.attrs();
        let macro_root_path = macro_root_path.iter().collect::<Vec<_>>();
        tokens.push(quote! {
            #attrs
            #(#periph_macro_attrs)*
            #[macro_export]
            macro_rules! #periph_macro {
                ($reg:ident) => {
                    $crate#(#macro_root_path)*::#periph_struct::<
                        $crate#(#macro_root_path)*::#periph_ty,
                    > {
                        #(#macro_tokens,)*
                    }
                };
            }
        });
    }

    let expanded = quote! {
        #(#periph_ty_attrs)*
        pub struct #periph_ty(());

        impl #periph_trait for #periph_ty {
            #(#periph_items)*
        }

        #(#tokens)*
    };
    expanded.into()
}