// SPDX-License-Identifier: LGPL-3.0-or-later
// See Notices.txt for copyright information
#![cfg_attr(test, recursion_limit = "512")]
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use std::{
    collections::{hash_map::Entry, HashMap},
    io::{ErrorKind, Write},
};
use syn::{
    bracketed,
    ext::IdentExt,
    parenthesized,
    parse::{Parse, ParseStream, Parser},
    parse_quote,
    punctuated::{Pair, Punctuated},
    spanned::Spanned,
    token::{Bracket, Paren},
    AttrStyle, Attribute, Error, Ident, Item, ItemFn, LitBool, LitStr, Meta, Token,
};

mod fold;
mod hdl_bundle;
mod hdl_enum;
mod hdl_type_alias;
mod hdl_type_common;
mod module;
mod process_cfg;

pub(crate) trait CustomToken:
    Copy
    + Spanned
    + ToTokens
    + std::fmt::Debug
    + Eq
    + std::hash::Hash
    + Default
    + quote::IdentFragment
    + Parse
{
    const IDENT_STR: &'static str;
}

mod kw {
    pub(crate) use syn::token::Extern as extern_;

    macro_rules! custom_keyword {
        ($kw:ident) => {
            syn::custom_keyword!($kw);

            impl quote::IdentFragment for $kw {
                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                    f.write_str(stringify!($kw))
                }

                fn span(&self) -> Option<proc_macro2::Span> {
                    Some(self.span)
                }
            }

            crate::fold::no_op_fold!($kw);

            impl crate::CustomToken for $kw {
                const IDENT_STR: &'static str = stringify!($kw);
            }
        };
    }

    custom_keyword!(__evaluated_cfgs);
    custom_keyword!(all);
    custom_keyword!(any);
    custom_keyword!(cfg);
    custom_keyword!(cfg_attr);
    custom_keyword!(clock_domain);
    custom_keyword!(cmp_eq);
    custom_keyword!(connect_inexact);
    custom_keyword!(custom_bounds);
    custom_keyword!(flip);
    custom_keyword!(hdl);
    custom_keyword!(hdl_module);
    custom_keyword!(incomplete_wire);
    custom_keyword!(input);
    custom_keyword!(instance);
    custom_keyword!(m);
    custom_keyword!(memory);
    custom_keyword!(memory_array);
    custom_keyword!(memory_with_init);
    custom_keyword!(no_reset);
    custom_keyword!(no_runtime_generics);
    custom_keyword!(no_static);
    custom_keyword!(not);
    custom_keyword!(outline_generated);
    custom_keyword!(output);
    custom_keyword!(reg_builder);
    custom_keyword!(reset);
    custom_keyword!(sim);
    custom_keyword!(skip);
    custom_keyword!(target);
    custom_keyword!(wire);
}

type Pound = Token![#]; // work around https://github.com/rust-lang/rust/issues/50676

#[derive(Clone, Debug)]
pub(crate) struct HdlAttr<T, KW> {
    pub(crate) pound_token: Pound,
    pub(crate) style: AttrStyle,
    pub(crate) bracket_token: syn::token::Bracket,
    pub(crate) kw: KW,
    pub(crate) paren_token: Option<syn::token::Paren>,
    pub(crate) body: T,
}

crate::fold::impl_fold! {
    struct HdlAttr<T, KW,> {
        pound_token: Pound,
        style: AttrStyle,
        bracket_token: syn::token::Bracket,
        kw: KW,
        paren_token: Option<syn::token::Paren>,
        body: T,
    }
}

#[allow(dead_code)]
impl<T, KW> HdlAttr<T, KW> {
    pub(crate) fn split_body(self) -> (HdlAttr<(), KW>, T) {
        let Self {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body,
        } = self;
        (
            HdlAttr {
                pound_token,
                style,
                bracket_token,
                kw,
                paren_token,
                body: (),
            },
            body,
        )
    }
    pub(crate) fn replace_body<T2>(self, body: T2) -> HdlAttr<T2, KW> {
        let Self {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body: _,
        } = self;
        HdlAttr {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body,
        }
    }
    pub(crate) fn as_ref(&self) -> HdlAttr<&T, KW>
    where
        KW: Clone,
    {
        let Self {
            pound_token,
            style,
            bracket_token,
            ref kw,
            paren_token,
            ref body,
        } = *self;
        HdlAttr {
            pound_token,
            style,
            bracket_token,
            kw: kw.clone(),
            paren_token,
            body,
        }
    }
    pub(crate) fn try_map<R, E, F: FnOnce(T) -> Result<R, E>>(
        self,
        f: F,
    ) -> Result<HdlAttr<R, KW>, E> {
        let Self {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body,
        } = self;
        Ok(HdlAttr {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body: f(body)?,
        })
    }
    pub(crate) fn map<R, F: FnOnce(T) -> R>(self, f: F) -> HdlAttr<R, KW> {
        let Self {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body,
        } = self;
        HdlAttr {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body: f(body),
        }
    }
    fn to_attr(&self) -> Attribute
    where
        T: ToTokens,
        KW: ToTokens,
    {
        parse_quote! { #self }
    }
}

impl<T: Default, KW: Default> Default for HdlAttr<T, KW> {
    fn default() -> Self {
        T::default().into()
    }
}

impl<T, KW: Default> From<T> for HdlAttr<T, KW> {
    fn from(body: T) -> Self {
        HdlAttr {
            pound_token: Default::default(),
            style: AttrStyle::Outer,
            bracket_token: Default::default(),
            kw: Default::default(),
            paren_token: Default::default(),
            body,
        }
    }
}

impl<T: ToTokens, KW: ToTokens + Spanned> ToTokens for HdlAttr<T, KW> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        self.pound_token.to_tokens(tokens);
        match self.style {
            AttrStyle::Inner(style) => style.to_tokens(tokens),
            AttrStyle::Outer => {}
        };
        self.bracket_token.surround(tokens, |tokens| {
            self.kw.to_tokens(tokens);
            match self.paren_token {
                Some(paren_token) => {
                    paren_token.surround(tokens, |tokens| self.body.to_tokens(tokens))
                }
                None => {
                    let body = self.body.to_token_stream();
                    if !body.is_empty() {
                        syn::token::Paren(self.kw.span())
                            .surround(tokens, |tokens| tokens.extend([body]));
                    }
                }
            }
        });
    }
}

fn is_hdl_attr<KW: CustomToken>(attr: &Attribute) -> bool {
    attr.path().is_ident(KW::IDENT_STR)
}

impl<T: Parse, KW: Parse> HdlAttr<T, KW> {
    fn parse_and_take_attr(attrs: &mut Vec<Attribute>) -> syn::Result<Option<Self>>
    where
        KW: ToTokens,
    {
        let mut retval = None;
        let mut errors = Errors::new();
        attrs.retain(|attr| {
            if let Ok(kw) = syn::parse2::<KW>(attr.path().to_token_stream()) {
                if retval.is_some() {
                    errors.push(Error::new_spanned(
                        attr,
                        format_args!("more than one #[{}] attribute", kw.to_token_stream()),
                    ));
                }
                errors.unwrap_or_default(Self::parse_attr(attr).map(|v| retval = Some(v)));
                false
            } else {
                true
            }
        });
        errors.finish()?;
        Ok(retval)
    }
    fn parse_and_leave_attr(attrs: &[Attribute]) -> syn::Result<Option<Self>>
    where
        KW: ToTokens,
    {
        let mut retval = None;
        let mut errors = Errors::new();
        for attr in attrs {
            if let Ok(kw) = syn::parse2::<KW>(attr.path().to_token_stream()) {
                if retval.is_some() {
                    errors.push(Error::new_spanned(
                        attr,
                        format_args!("more than one #[{}] attribute", kw.to_token_stream()),
                    ));
                }
                errors.unwrap_or_default(Self::parse_attr(attr).map(|v| retval = Some(v)));
            }
        }
        errors.finish()?;
        Ok(retval)
    }
    fn parse_attr(attr: &Attribute) -> syn::Result<Self> {
        match attr.style {
            AttrStyle::Outer => Parser::parse2(Self::parse_outer, attr.to_token_stream()),
            AttrStyle::Inner(_) => Parser::parse2(Self::parse_inner, attr.to_token_stream()),
        }
    }
    fn parse_starting_with_brackets(
        pound_token: Token![#],
        style: AttrStyle,
        input: ParseStream,
    ) -> syn::Result<Self> {
        let bracket_content;
        let bracket_token = bracketed!(bracket_content in input);
        let kw = bracket_content.parse()?;
        let paren_content;
        let body;
        let paren_token;
        if bracket_content.is_empty() {
            body = match syn::parse2(TokenStream::default()) {
                Ok(body) => body,
                Err(_) => {
                    parenthesized!(paren_content in bracket_content);
                    unreachable!();
                }
            };
            paren_token = None;
        } else {
            paren_token = Some(parenthesized!(paren_content in bracket_content));
            body = paren_content.parse()?;
        }
        Ok(Self {
            pound_token,
            style,
            bracket_token,
            kw,
            paren_token,
            body,
        })
    }
    fn parse_inner(input: ParseStream) -> syn::Result<Self> {
        let pound_token = input.parse()?;
        let style = AttrStyle::Inner(input.parse()?);
        Self::parse_starting_with_brackets(pound_token, style, input)
    }
    fn parse_outer(input: ParseStream) -> syn::Result<Self> {
        let pound_token = input.parse()?;
        let style = AttrStyle::Outer;
        Self::parse_starting_with_brackets(pound_token, style, input)
    }
}

#[allow(dead_code)]
pub(crate) trait PairsIterExt: Sized + Iterator {
    fn map_pair<T1, T2, P1, P2, ValueFn: FnMut(T1) -> T2, PunctFn: FnMut(P1) -> P2>(
        self,
        mut value_fn: ValueFn,
        mut punct_fn: PunctFn,
    ) -> impl Iterator<Item = Pair<T2, P2>>
    where
        Self: Iterator<Item = Pair<T1, P1>>,
    {
        self.map(move |p| {
            let (t, p) = p.into_tuple();
            let t = value_fn(t);
            let p = p.map(&mut punct_fn);
            Pair::new(t, p)
        })
    }
    fn filter_map_pair<T1, T2, P1, P2, ValueFn: FnMut(T1) -> Option<T2>, PunctFn: FnMut(P1) -> P2>(
        self,
        mut value_fn: ValueFn,
        mut punct_fn: PunctFn,
    ) -> impl Iterator<Item = Pair<T2, P2>>
    where
        Self: Iterator<Item = Pair<T1, P1>>,
    {
        self.filter_map(move |p| {
            let (t, p) = p.into_tuple();
            let t = value_fn(t)?;
            let p = p.map(&mut punct_fn);
            Some(Pair::new(t, p))
        })
    }
    fn map_pair_value<T1, T2, P, F: FnMut(T1) -> T2>(
        self,
        f: F,
    ) -> impl Iterator<Item = Pair<T2, P>>
    where
        Self: Iterator<Item = Pair<T1, P>>,
    {
        self.map_pair(f, |v| v)
    }
    fn filter_map_pair_value<T1, T2, P, F: FnMut(T1) -> Option<T2>>(
        self,
        f: F,
    ) -> impl Iterator<Item = Pair<T2, P>>
    where
        Self: Iterator<Item = Pair<T1, P>>,
    {
        self.filter_map_pair(f, |v| v)
    }
    fn map_pair_value_mut<'a, T1: 'a, T2: 'a, P: Clone + 'a, F: FnMut(T1) -> T2 + 'a>(
        self,
        f: F,
    ) -> impl Iterator<Item = Pair<T2, P>> + 'a
    where
        Self: Iterator<Item = Pair<T1, &'a mut P>> + 'a,
    {
        self.map_pair(f, |v| v.clone())
    }
    fn filter_map_pair_value_mut<
        'a,
        T1: 'a,
        T2: 'a,
        P: Clone + 'a,
        F: FnMut(T1) -> Option<T2> + 'a,
    >(
        self,
        f: F,
    ) -> impl Iterator<Item = Pair<T2, P>> + 'a
    where
        Self: Iterator<Item = Pair<T1, &'a mut P>> + 'a,
    {
        self.filter_map_pair(f, |v| v.clone())
    }
    fn map_pair_value_ref<'a, T1: 'a, T2: 'a, P: Clone + 'a, F: FnMut(T1) -> T2 + 'a>(
        self,
        f: F,
    ) -> impl Iterator<Item = Pair<T2, P>> + 'a
    where
        Self: Iterator<Item = Pair<T1, &'a P>> + 'a,
    {
        self.map_pair(f, |v| v.clone())
    }
    fn filter_map_pair_value_ref<
        'a,
        T1: 'a,
        T2: 'a,
        P: Clone + 'a,
        F: FnMut(T1) -> Option<T2> + 'a,
    >(
        self,
        f: F,
    ) -> impl Iterator<Item = Pair<T2, P>> + 'a
    where
        Self: Iterator<Item = Pair<T1, &'a P>> + 'a,
    {
        self.filter_map_pair(f, |v| v.clone())
    }
}

impl<T, P, Iter: Iterator<Item = Pair<T, P>>> PairsIterExt for Iter {}

pub(crate) struct Errors {
    error: Option<Error>,
    finished: bool,
}

impl Drop for Errors {
    fn drop(&mut self) {
        if !std::thread::panicking() {
            assert!(self.finished, "didn't run finish");
        }
    }
}

impl Errors {
    pub(crate) fn new() -> Self {
        Self {
            error: None,
            finished: false,
        }
    }
    pub(crate) fn push(&mut self, e: Error) -> &mut Self {
        match self.error {
            Some(ref mut old) => old.combine(e),
            None => self.error = Some(e),
        }
        self
    }
    pub(crate) fn push_result(&mut self, e: syn::Result<()>) -> &mut Self {
        self.ok(e);
        self
    }
    pub(crate) fn error(
        &mut self,
        tokens: impl ToTokens,
        message: impl std::fmt::Display,
    ) -> &mut Self {
        self.push(Error::new_spanned(tokens, message));
        self
    }
    pub(crate) fn ok<T>(&mut self, v: syn::Result<T>) -> Option<T> {
        match v {
            Ok(v) => Some(v),
            Err(e) => {
                self.push(e);
                None
            }
        }
    }
    pub(crate) fn unwrap_or_else<T>(
        &mut self,
        v: syn::Result<T>,
        fallback: impl FnOnce() -> T,
    ) -> T {
        match v {
            Ok(v) => v,
            Err(e) => {
                self.push(e);
                fallback()
            }
        }
    }
    pub(crate) fn unwrap_or<T>(&mut self, v: syn::Result<T>, fallback: T) -> T {
        self.unwrap_or_else(v, || fallback)
    }
    pub(crate) fn unwrap_or_default<T: Default>(&mut self, v: syn::Result<T>) -> T {
        self.unwrap_or_else(v, T::default)
    }
    pub(crate) fn finish(&mut self) -> syn::Result<()> {
        self.finished = true;
        match self.error.take() {
            Some(e) => Err(e),
            None => Ok(()),
        }
    }
}

impl Default for Errors {
    fn default() -> Self {
        Self::new()
    }
}

macro_rules! impl_extra_traits_for_options {
    (
        #[no_ident_fragment]
        $enum_vis:vis enum $option_enum_name:ident {
            $($Variant:ident($key:ident),)*
        }
    ) => {
        impl Copy for $option_enum_name {}
    };
    (
        $enum_vis:vis enum $option_enum_name:ident {
            $($Variant:ident($key:ident),)*
        }
    ) => {
        impl Copy for $option_enum_name {}

        impl PartialEq for $option_enum_name {
            fn eq(&self, other: &Self) -> bool {
                self.cmp(other).is_eq()
            }
        }

        impl Eq for $option_enum_name {}

        impl PartialOrd for $option_enum_name {
            fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
                Some(self.cmp(other))
            }
        }

        impl Ord for $option_enum_name {
            fn cmp(&self, other: &Self) -> std::cmp::Ordering {
                self.variant().cmp(&other.variant())
            }
        }

        impl quote::IdentFragment for $option_enum_name {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                let _ = f;
                match *self {
                    $(Self::$Variant(ref v) => quote::IdentFragment::fmt(&v.0, f),)*
                }
            }

            fn span(&self) -> Option<proc_macro2::Span> {
                match *self {
                    $(Self::$Variant(ref v) => quote::IdentFragment::span(&v.0),)*
                }
            }
        }

        impl $option_enum_name {
            #[allow(dead_code)]
            $enum_vis fn span(&self) -> proc_macro2::Span {
                quote::IdentFragment::span(self).unwrap()
            }
        }
    };
    (
        $(#[no_ident_fragment])?
        $enum_vis:vis enum $option_enum_name:ident {
            $($Variant:ident($key:ident $(, $value:ty)?),)*
        }
    ) => {};
}

pub(crate) use impl_extra_traits_for_options;

macro_rules! options {
    (
        #[options = $options_name:ident]
        $($tt:tt)*
    ) => {
        crate::options! {
            #[options = $options_name, punct = syn::Token![,], allow_duplicates = false]
            $($tt)*
        }
    };
    (
        #[options = $options_name:ident, punct = $Punct:ty, allow_duplicates = true]
        $(#[$($enum_meta:tt)*])*
        $enum_vis:vis enum $option_enum_name:ident {
            $($Variant:ident($key:ident $(, $value:ty)?),)*
        }
    ) => {
        crate::options! {
            #[options = $options_name, punct = $Punct, allow_duplicates = (true)]
            $(#[$($enum_meta)*])*
            $enum_vis enum $option_enum_name {
                $($Variant($key $(, $value)?),)*
            }
        }

        impl Extend<$option_enum_name> for $options_name {
            fn extend<T: IntoIterator<Item = $option_enum_name>>(&mut self, iter: T) {
                iter.into_iter().for_each(|v| match v {
                    $($option_enum_name::$Variant(v) => {
                        self.$key = Some(v);
                    })*
                });
            }
        }

        impl FromIterator<$option_enum_name> for $options_name {
            fn from_iter<T: IntoIterator<Item = $option_enum_name>>(iter: T) -> Self {
                let mut retval = Self::default();
                retval.extend(iter);
                retval
            }
        }

        impl Extend<$options_name> for $options_name {
            fn extend<T: IntoIterator<Item = $options_name>>(&mut self, iter: T) {
                iter.into_iter().for_each(|v| {
                    $(if let Some(v) = v.$key {
                        self.$key = Some(v);
                    })*
                });
            }
        }

        impl FromIterator<$options_name> for $options_name {
            fn from_iter<T: IntoIterator<Item = $options_name>>(iter: T) -> Self {
                let mut retval = Self::default();
                retval.extend(iter);
                retval
            }
        }
    };
    (
        #[options = $options_name:ident, punct = $Punct:ty, allow_duplicates = $allow_duplicates:expr]
        $(#[$($enum_meta:tt)*])*
        $enum_vis:vis enum $option_enum_name:ident {
            $($Variant:ident($key:ident $(, $value:ty)?),)*
        }
    ) => {
        crate::options! {
            $(#[$($enum_meta)*])*
            $enum_vis enum $option_enum_name {
                $($Variant($key $(, $value)?),)*
            }
        }

        #[derive(Clone, Debug, Default)]
        #[allow(non_snake_case)]
        $enum_vis struct $options_name {
            $(
                $enum_vis $key: Option<(crate::kw::$key, $(syn::token::Paren, $value)?)>,
            )*
        }

        crate::fold::impl_fold! {
            struct $options_name<> {
                $($key: Option<(crate::kw::$key, $(syn::token::Paren, $value)?)>,)*
            }
        }

        const _: () = {
            #[derive(Clone, Debug)]
            $enum_vis struct Iter($enum_vis $options_name);

            impl IntoIterator for $options_name {
                type Item = $option_enum_name;
                type IntoIter = Iter;

                fn into_iter(self) -> Self::IntoIter {
                    Iter(self)
                }
            }

            impl Iterator for Iter {
                type Item = $option_enum_name;

                fn next(&mut self) -> Option<Self::Item> {
                    $(
                        if let Some(value) = self.0.$key.take() {
                            return Some($option_enum_name::$Variant(value));
                        }
                    )*
                    None
                }

                #[allow(unused_mut, unused_variables)]
                fn fold<B, F: FnMut(B, Self::Item) -> B>(mut self, mut init: B, mut f: F) -> B {
                    $(
                        if let Some(value) = self.0.$key.take() {
                            init = f(init, $option_enum_name::$Variant(value));
                        }
                    )*
                    init
                }
            }
        };

        impl syn::parse::Parse for $options_name {
            fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
                #![allow(unused_mut, unused_variables, unreachable_code)]
                let mut retval = Self::default();
                while !input.is_empty() {
                    let old_input = input.fork();
                    match input.parse::<$option_enum_name>()? {
                        $($option_enum_name::$Variant(v) => {
                            if retval.$key.replace(v).is_some() && !$allow_duplicates {
                                return Err(old_input.error(concat!("duplicate ", stringify!($key), " option")));
                            }
                        })*
                    }
                    if input.is_empty() {
                        break;
                    }
                    input.parse::<$Punct>()?;
                }
                Ok(retval)
            }
        }

        impl quote::ToTokens for $options_name {
            #[allow(unused_mut, unused_variables, unused_assignments)]
            fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
                let mut separator: Option<$Punct> = None;
                $(if let Some(v) = &self.$key {
                    separator.to_tokens(tokens);
                    separator = Some(Default::default());
                    v.0.to_tokens(tokens);
                    $(v.1.surround(
                        tokens,
                        |tokens| <$value as quote::ToTokens>::to_tokens(&v.2, tokens),
                    );)?
                })*
            }
        }
    };
    (
        $(#[$($enum_meta:tt)*])*
        $enum_vis:vis enum $option_enum_name:ident {
            $($Variant:ident($key:ident $(, $value:ty)?),)*
        }
    ) => {
        #[derive(Clone, Debug)]
        $enum_vis enum $option_enum_name {
            $($Variant((crate::kw::$key, $(syn::token::Paren, $value)?)),)*
        }

        crate::impl_extra_traits_for_options! {
            $(#[$($enum_meta)*])*
            $enum_vis enum $option_enum_name {
                $($Variant($key $(, $value)?),)*
            }
        }

        crate::fold::impl_fold! {
            enum $option_enum_name<> {
                $($Variant((crate::kw::$key, $(syn::token::Paren, $value)?)),)*
            }
        }

        impl syn::parse::Parse for $option_enum_name {
            fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
                let lookahead = input.lookahead1();
                $(
                    if lookahead.peek(crate::kw::$key) {
                        #[allow(unused_variables)]
                        let paren_content: syn::parse::ParseBuffer;
                        return Ok($option_enum_name::$Variant((
                            input.parse()?,
                            $(
                                syn::parenthesized!(paren_content in input),
                                paren_content.parse::<$value>()?,
                            )?
                        )));
                    }
                )*
                Err(lookahead.error())
            }
        }

        impl quote::ToTokens for $option_enum_name {
            fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
                let _ = tokens;
                match *self {
                    $($option_enum_name::$Variant(ref v) => {
                        v.0.to_tokens(tokens);
                        $(
                            let value: &$value = &v.2;
                            v.1.surround(tokens, |tokens| value.to_tokens(tokens));
                        )?
                    })*
                }
            }
        }

        impl $option_enum_name {
            #[allow(dead_code)]
            fn variant(&self) -> usize {
                #[repr(usize)]
                enum Variant {
                    $($Variant,)*
                    __Last, // so it doesn't complain about zero-variant enums
                }
                match *self {
                    $(Self::$Variant(..) => Variant::$Variant as usize,)*
                }
            }
        }
    };
}

use crate::hdl_type_alias::hdl_type_alias_impl;
pub(crate) use options;

pub(crate) fn outline_generated(contents: TokenStream, prefix: &str) -> TokenStream {
    let out_dir = env!("OUT_DIR");
    let mut file = tempfile::Builder::new()
        .prefix(prefix)
        .rand_bytes(6)
        .suffix(".tmp.rs")
        .tempfile_in(out_dir)
        .unwrap();
    struct PrintOnPanic<'a>(&'a TokenStream);
    impl Drop for PrintOnPanic<'_> {
        fn drop(&mut self) {
            if std::thread::panicking() {
                println!("{}", self.0);
            }
        }
    }
    let _print_on_panic = PrintOnPanic(&contents);
    let contents = prettyplease::unparse(&parse_quote! { #contents });
    let hash = <sha2::Sha256 as sha2::Digest>::digest(&contents);
    let hash = base16ct::HexDisplay(&hash[..5]);
    file.write_all(contents.as_bytes()).unwrap();
    let dest_file = std::path::Path::new(out_dir).join(format!("{prefix}{hash:x}.rs"));
    // don't write if it already exists so cargo doesn't try to recompile constantly.
    match file.persist_noclobber(&dest_file) {
        Err(e) if e.error.kind() == ErrorKind::AlreadyExists => {}
        e => {
            e.unwrap();
        }
    }
    eprintln!("generated {}", dest_file.display());
    let dest_file = dest_file.to_str().unwrap();

    quote! {
        include!(#dest_file);
    }
}

fn hdl_module_impl(item: ItemFn) -> syn::Result<TokenStream> {
    let func = module::ModuleFn::parse_from_fn(item)?;
    let options = func.config_options();
    let mut contents = func.generate();
    if options.outline_generated.is_some() {
        contents = outline_generated(contents, "module-");
    }
    Ok(contents)
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) enum CfgExpr {
    Option {
        ident: Ident,
        value: Option<(Token![=], LitStr)>,
    },
    All {
        all: kw::all,
        paren: Paren,
        exprs: Punctuated<CfgExpr, Token![,]>,
    },
    Any {
        any: kw::any,
        paren: Paren,
        exprs: Punctuated<CfgExpr, Token![,]>,
    },
    Not {
        not: kw::not,
        paren: Paren,
        expr: Box<CfgExpr>,
        trailing_comma: Option<Token![,]>,
    },
}

impl Parse for CfgExpr {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        match input.cursor().ident() {
            Some((_, cursor)) if cursor.eof() => {
                return Ok(CfgExpr::Option {
                    ident: input.call(Ident::parse_any)?,
                    value: None,
                });
            }
            _ => {}
        }
        if input.peek(Ident::peek_any) && input.peek2(Token![=]) {
            return Ok(CfgExpr::Option {
                ident: input.call(Ident::parse_any)?,
                value: Some((input.parse()?, input.parse()?)),
            });
        }
        let contents;
        if input.peek(kw::all) {
            Ok(CfgExpr::All {
                all: input.parse()?,
                paren: parenthesized!(contents in input),
                exprs: contents.call(Punctuated::parse_terminated)?,
            })
        } else if input.peek(kw::any) {
            Ok(CfgExpr::Any {
                any: input.parse()?,
                paren: parenthesized!(contents in input),
                exprs: contents.call(Punctuated::parse_terminated)?,
            })
        } else if input.peek(kw::not) {
            Ok(CfgExpr::Not {
                not: input.parse()?,
                paren: parenthesized!(contents in input),
                expr: contents.parse()?,
                trailing_comma: contents.parse()?,
            })
        } else {
            Err(input.error("expected cfg-pattern"))
        }
    }
}

impl ToTokens for CfgExpr {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        match self {
            CfgExpr::Option { ident, value } => {
                ident.to_tokens(tokens);
                if let Some((eq, value)) = value {
                    eq.to_tokens(tokens);
                    value.to_tokens(tokens);
                }
            }
            CfgExpr::All { all, paren, exprs } => {
                all.to_tokens(tokens);
                paren.surround(tokens, |tokens| exprs.to_tokens(tokens));
            }
            CfgExpr::Any { any, paren, exprs } => {
                any.to_tokens(tokens);
                paren.surround(tokens, |tokens| exprs.to_tokens(tokens));
            }
            CfgExpr::Not {
                not,
                paren,
                expr,
                trailing_comma,
            } => {
                not.to_tokens(tokens);
                paren.surround(tokens, |tokens| {
                    expr.to_tokens(tokens);
                    trailing_comma.to_tokens(tokens);
                });
            }
        }
    }
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct Cfg {
    cfg: kw::cfg,
    paren: Paren,
    expr: CfgExpr,
    trailing_comma: Option<Token![,]>,
}

impl Cfg {
    fn parse_meta(meta: &Meta) -> syn::Result<Self> {
        syn::parse2(meta.to_token_stream())
    }
}

impl ToTokens for Cfg {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            cfg,
            paren,
            expr,
            trailing_comma,
        } = self;
        cfg.to_tokens(tokens);
        paren.surround(tokens, |tokens| {
            expr.to_tokens(tokens);
            trailing_comma.to_tokens(tokens);
        });
    }
}

impl Parse for Cfg {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let contents;
        Ok(Self {
            cfg: input.parse()?,
            paren: parenthesized!(contents in input),
            expr: contents.parse()?,
            trailing_comma: contents.parse()?,
        })
    }
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub(crate) struct CfgAttr {
    cfg_attr: kw::cfg_attr,
    paren: Paren,
    expr: CfgExpr,
    comma: Token![,],
    attrs: Punctuated<Meta, Token![,]>,
}

impl CfgAttr {
    pub(crate) fn to_cfg(&self) -> Cfg {
        Cfg {
            cfg: kw::cfg(self.cfg_attr.span),
            paren: self.paren,
            expr: self.expr.clone(),
            trailing_comma: None,
        }
    }
    fn parse_meta(meta: &Meta) -> syn::Result<Self> {
        syn::parse2(meta.to_token_stream())
    }
}

impl Parse for CfgAttr {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let contents;
        Ok(Self {
            cfg_attr: input.parse()?,
            paren: parenthesized!(contents in input),
            expr: contents.parse()?,
            comma: contents.parse()?,
            attrs: contents.call(Punctuated::parse_terminated)?,
        })
    }
}

pub(crate) struct CfgAndValue {
    cfg: Cfg,
    eq_token: Token![=],
    value: LitBool,
}

impl Parse for CfgAndValue {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(Self {
            cfg: input.parse()?,
            eq_token: input.parse()?,
            value: input.parse()?,
        })
    }
}

pub(crate) struct Cfgs<T> {
    pub(crate) bracket: Bracket,
    pub(crate) cfgs_map: HashMap<Cfg, T>,
    pub(crate) cfgs_list: Vec<Cfg>,
}

impl<T> Default for Cfgs<T> {
    fn default() -> Self {
        Self {
            bracket: Default::default(),
            cfgs_map: Default::default(),
            cfgs_list: Default::default(),
        }
    }
}

impl<T> Cfgs<T> {
    fn insert_cfg(&mut self, cfg: Cfg, value: T) {
        match self.cfgs_map.entry(cfg) {
            Entry::Occupied(_) => {}
            Entry::Vacant(entry) => {
                self.cfgs_list.push(entry.key().clone());
                entry.insert(value);
            }
        }
    }
}

impl Parse for Cfgs<bool> {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let contents;
        let bracket = bracketed!(contents in input);
        let mut cfgs_map = HashMap::new();
        let mut cfgs_list = Vec::new();
        for CfgAndValue {
            cfg,
            eq_token,
            value,
        } in contents.call(Punctuated::<CfgAndValue, Token![,]>::parse_terminated)?
        {
            let _ = eq_token;
            match cfgs_map.entry(cfg) {
                Entry::Occupied(_) => {}
                Entry::Vacant(entry) => {
                    cfgs_list.push(entry.key().clone());
                    entry.insert(value.value);
                }
            }
        }
        Ok(Self {
            bracket,
            cfgs_map,
            cfgs_list,
        })
    }
}

impl Parse for Cfgs<()> {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let contents;
        let bracket = bracketed!(contents in input);
        let mut cfgs_map = HashMap::new();
        let mut cfgs_list = Vec::new();
        for cfg in contents.call(Punctuated::<Cfg, Token![,]>::parse_terminated)? {
            match cfgs_map.entry(cfg) {
                Entry::Occupied(_) => {}
                Entry::Vacant(entry) => {
                    cfgs_list.push(entry.key().clone());
                    entry.insert(());
                }
            }
        }
        Ok(Self {
            bracket,
            cfgs_map,
            cfgs_list,
        })
    }
}

impl ToTokens for Cfgs<()> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            bracket,
            cfgs_map: _,
            cfgs_list,
        } = self;
        bracket.surround(tokens, |tokens| {
            for cfg in cfgs_list {
                cfg.to_tokens(tokens);
                <Token![,]>::default().to_tokens(tokens);
            }
        });
    }
}

fn hdl_main(
    kw: impl CustomToken,
    attr: TokenStream,
    item: TokenStream,
) -> syn::Result<TokenStream> {
    fn parse_evaluated_cfgs_attr<R>(
        input: ParseStream,
        parse_inner: impl FnOnce(ParseStream) -> syn::Result<R>,
    ) -> syn::Result<R> {
        let _: Token![#] = input.parse()?;
        let bracket_content;
        bracketed!(bracket_content in input);
        let _: kw::__evaluated_cfgs = bracket_content.parse()?;
        let paren_content;
        parenthesized!(paren_content in bracket_content);
        parse_inner(&paren_content)
    }
    let (evaluated_cfgs, item): (_, TokenStream) = Parser::parse2(
        |input: ParseStream| {
            let peek = input.fork();
            if parse_evaluated_cfgs_attr(&peek, |_| Ok(())).is_ok() {
                let evaluated_cfgs = parse_evaluated_cfgs_attr(input, Cfgs::<bool>::parse)?;
                Ok((Some(evaluated_cfgs), input.parse()?))
            } else {
                Ok((None, input.parse()?))
            }
        },
        item,
    )?;
    let cfgs = if let Some(cfgs) = evaluated_cfgs {
        cfgs
    } else {
        let cfgs = process_cfg::collect_cfgs(syn::parse2(item.clone())?)?;
        if cfgs.cfgs_list.is_empty() {
            Cfgs::default()
        } else {
            return Ok(quote! {
                ::fayalite::__cfg_expansion_helper! {
                    []
                    #cfgs
                    {#[::fayalite::#kw(#attr)]} { #item }
                }
            });
        }
    };
    let item = syn::parse2(quote! { #[#kw(#attr)] #item })?;
    let Some(item) = process_cfg::process_cfgs(item, cfgs)? else {
        return Ok(TokenStream::new());
    };
    match item {
        Item::Enum(item) => hdl_enum::hdl_enum(item),
        Item::Struct(item) => hdl_bundle::hdl_bundle(item),
        Item::Fn(item) => hdl_module_impl(item),
        Item::Type(item) => hdl_type_alias_impl(item),
        _ => Err(syn::Error::new(
            Span::call_site(),
            "top-level #[hdl] can only be used on structs, enums, type aliases, or functions",
        )),
    }
}

pub fn hdl_module(attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream> {
    hdl_main(kw::hdl_module::default(), attr, item)
}

pub fn hdl_attr(attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream> {
    hdl_main(kw::hdl::default(), attr, item)
}