fayalite/crates/fayalite-proc-macros-impl/src/lib.rs

// 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::io::{ErrorKind, Write};
use syn::{
    bracketed, parenthesized,
    parse::{Parse, ParseStream, Parser},
    parse_quote, AttrStyle, Attribute, Error, Item, Token,
};

mod fold;
mod module;
mod value_derive_common;
mod value_derive_enum;
mod value_derive_struct;

mod kw {
    pub(crate) use syn::token::{
        Enum as enum_, Extern as extern_, Struct as struct_, Where as where_,
    };

    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);
        };
    }

    custom_keyword!(clock_domain);
    custom_keyword!(connect_inexact);
    custom_keyword!(fixed_type);
    custom_keyword!(flip);
    custom_keyword!(hdl);
    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!(outline_generated);
    custom_keyword!(output);
    custom_keyword!(reg_builder);
    custom_keyword!(reset);
    custom_keyword!(reset_default);
    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> {
    pub(crate) pound_token: Pound,
    pub(crate) style: AttrStyle,
    pub(crate) bracket_token: syn::token::Bracket,
    pub(crate) hdl: kw::hdl,
    pub(crate) paren_token: Option<syn::token::Paren>,
    pub(crate) body: T,
}

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

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

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

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

impl<T: ToTokens> ToTokens for HdlAttr<T> {
    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.hdl.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.hdl.span)
                            .surround(tokens, |tokens| tokens.extend([body]));
                    }
                }
            }
        });
    }
}

fn is_hdl_attr(attr: &Attribute) -> bool {
    attr.path().is_ident("hdl")
}

impl<T: Parse> HdlAttr<T> {
    fn parse_and_take_attr(attrs: &mut Vec<Attribute>) -> syn::Result<Option<Self>> {
        let mut retval = None;
        let mut errors = Errors::new();
        attrs.retain(|attr| {
            if is_hdl_attr(attr) {
                if retval.is_some() {
                    errors.push(Error::new_spanned(attr, "more than one #[hdl] attribute"));
                }
                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>> {
        let mut retval = None;
        let mut errors = Errors::new();
        for attr in attrs {
            if is_hdl_attr(attr) {
                if retval.is_some() {
                    errors.push(Error::new_spanned(attr, "more than one #[hdl] attribute"));
                }
                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 hdl = 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,
            hdl,
            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)
    }
}

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 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]
        $(#[$($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)]
        $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)?)>,)*
            }
        }

        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() {
                                return Err(old_input.error(concat!("duplicate ", stringify!($key), " option")));
                            }
                        })*
                    }
                    if input.is_empty() {
                        break;
                    }
                    input.parse::<syn::Token![,]>()?;
                }
                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<syn::Token![,]> = 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));
                        )?
                    })*
                }
            }
        }
    };
}

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();
    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);
    }
}

pub fn module(attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream> {
    let options = syn::parse2::<module::ConfigOptions>(attr)?;
    let options = HdlAttr::from(options);
    let func = syn::parse2::<module::ModuleFn>(quote! { #options #item })?;
    let mut contents = func.generate();
    if options.body.outline_generated.is_some() {
        contents = outline_generated(contents, "module-");
    }
    Ok(contents)
}

pub fn value_derive(item: TokenStream) -> syn::Result<TokenStream> {
    let item = syn::parse2::<Item>(item)?;
    match item {
        Item::Enum(item) => value_derive_enum::value_derive_enum(item),
        Item::Struct(item) => value_derive_struct::value_derive_struct(item),
        _ => Err(syn::Error::new(
            Span::call_site(),
            "derive(Value) can only be used on structs or enums",
        )),
    }
}