WIP adding Platform

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

@@ -66,6 +66,7 @@ mod kw {
     }
 
     custom_keyword!(__evaluated_cfgs);
+    custom_keyword!(add_platform_io);
     custom_keyword!(all);
     custom_keyword!(any);
     custom_keyword!(cfg);

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

@@ -4,7 +4,7 @@ use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{ParsedGenerics, SplitForImpl},
     kw,
-    module::transform_body::{HdlLet, HdlLetKindIO},
+    module::transform_body::{HdlLet, HdlLetKindIO, ModuleIOOrAddPlatformIO},
     options,
 };
 use proc_macro2::TokenStream;
@@ -39,7 +39,7 @@ pub(crate) fn check_name_conflicts_with_module_builder(name: &Ident) -> syn::Res
     if name == "m" {
         Err(Error::new_spanned(
             name,
-            "name conflicts with implicit `m: &mut ModuleBuilder<_>`",
+            "name conflicts with implicit `m: &ModuleBuilder`",
         ))
     } else {
         Ok(())
@@ -67,7 +67,7 @@ struct ModuleFnModule {
     vis: Visibility,
     sig: Signature,
     block: Box<Block>,
-    struct_generics: ParsedGenerics,
+    struct_generics: Option<ParsedGenerics>,
     the_struct: TokenStream,
 }
 
@@ -290,7 +290,7 @@ impl ModuleFn {
                 paren_token,
                 body,
             } => {
-                debug_assert!(io.is_empty());
+                debug_assert!(matches!(io, ModuleIOOrAddPlatformIO::ModuleIO(v) if v.is_empty()));
                 return Ok(Self(ModuleFnImpl::Fn {
                     attrs,
                     config_options: HdlAttr {
@@ -322,6 +322,21 @@ impl ModuleFn {
                 body,
             },
         };
+        let io = match io {
+            ModuleIOOrAddPlatformIO::ModuleIO(io) => io,
+            ModuleIOOrAddPlatformIO::AddPlatformIO => {
+                return Ok(Self(ModuleFnImpl::Module(ModuleFnModule {
+                    attrs,
+                    config_options,
+                    module_kind: module_kind.unwrap(),
+                    vis,
+                    sig,
+                    block,
+                    struct_generics: None,
+                    the_struct: TokenStream::new(),
+                })));
+            }
+        };
         let (_struct_impl_generics, _struct_type_generics, struct_where_clause) =
             struct_generics.split_for_impl();
         let struct_where_clause: Option<WhereClause> = parse_quote! { #struct_where_clause };
@@ -364,7 +379,7 @@ impl ModuleFn {
             vis,
             sig,
             block,
-            struct_generics,
+            struct_generics: Some(struct_generics),
             the_struct,
         })))
     }
@@ -433,9 +448,14 @@ impl ModuleFn {
             ModuleKind::Normal => quote! { ::fayalite::module::ModuleKind::Normal },
         };
         let fn_name = &outer_sig.ident;
-        let (_struct_impl_generics, struct_type_generics, _struct_where_clause) =
-            struct_generics.split_for_impl();
-        let struct_ty = quote! {#fn_name #struct_type_generics};
+        let struct_ty = match struct_generics {
+            Some(struct_generics) => {
+                let (_struct_impl_generics, struct_type_generics, _struct_where_clause) =
+                    struct_generics.split_for_impl();
+                quote! {#fn_name #struct_type_generics}
+            }
+            None => quote! {::fayalite::bundle::Bundle},
+        };
         body_sig.ident = parse_quote! {__body};
         body_sig
             .inputs

crates/fayalite-proc-macros-impl/src/module/transform_body.rs

@@ -39,6 +39,7 @@ options! {
     pub(crate) enum LetFnKind {
         Input(input),
         Output(output),
+        AddPlatformIO(add_platform_io),
         Instance(instance),
         RegBuilder(reg_builder),
         Wire(wire),
@@ -216,6 +217,49 @@ impl HdlLetKindToTokens for HdlLetKindInstance {
     }
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct HdlLetKindAddPlatformIO {
+    pub(crate) m: kw::m,
+    pub(crate) dot_token: Token![.],
+    pub(crate) add_platform_io: kw::add_platform_io,
+    pub(crate) paren: Paren,
+    pub(crate) platform_io_builder: Box<Expr>,
+}
+
+impl ParseTypes<Self> for HdlLetKindAddPlatformIO {
+    fn parse_types(input: &mut Self, _parser: &mut TypesParser<'_>) -> Result<Self, ParseFailed> {
+        Ok(input.clone())
+    }
+}
+
+impl_fold! {
+    struct HdlLetKindAddPlatformIO<> {
+        m: kw::m,
+        dot_token: Token![.],
+        add_platform_io: kw::add_platform_io,
+        paren: Paren,
+        platform_io_builder: Box<Expr>,
+    }
+}
+
+impl HdlLetKindToTokens for HdlLetKindAddPlatformIO {
+    fn ty_to_tokens(&self, _tokens: &mut TokenStream) {}
+
+    fn expr_to_tokens(&self, tokens: &mut TokenStream) {
+        let Self {
+            m,
+            dot_token,
+            add_platform_io,
+            paren,
+            platform_io_builder,
+        } = self;
+        m.to_tokens(tokens);
+        dot_token.to_tokens(tokens);
+        add_platform_io.to_tokens(tokens);
+        paren.surround(tokens, |tokens| platform_io_builder.to_tokens(tokens));
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) struct RegBuilderClockDomain {
     pub(crate) dot_token: Token![.],
@@ -711,6 +755,7 @@ impl HdlLetKindMemory {
 #[derive(Clone, Debug)]
 pub(crate) enum HdlLetKind<IOType = ParsedType> {
     IO(HdlLetKindIO<ModuleIOKind, IOType>),
+    AddPlatformIO(HdlLetKindAddPlatformIO),
     Incomplete(HdlLetKindIncomplete),
     Instance(HdlLetKindInstance),
     RegBuilder(HdlLetKindRegBuilder),
@@ -721,6 +766,7 @@ pub(crate) enum HdlLetKind<IOType = ParsedType> {
 impl_fold! {
     enum HdlLetKind<IOType,> {
         IO(HdlLetKindIO<ModuleIOKind, IOType>),
+        AddPlatformIO(HdlLetKindAddPlatformIO),
         Incomplete(HdlLetKindIncomplete),
         Instance(HdlLetKindInstance),
         RegBuilder(HdlLetKindRegBuilder),
@@ -736,6 +782,9 @@ impl<T: ParseTypes<I>, I> ParseTypes<HdlLetKind<I>> for HdlLetKind<T> {
     ) -> Result<Self, ParseFailed> {
         match input {
             HdlLetKind::IO(input) => ParseTypes::parse_types(input, parser).map(HdlLetKind::IO),
+            HdlLetKind::AddPlatformIO(input) => {
+                ParseTypes::parse_types(input, parser).map(HdlLetKind::AddPlatformIO)
+            }
             HdlLetKind::Incomplete(input) => {
                 ParseTypes::parse_types(input, parser).map(HdlLetKind::Incomplete)
             }
@@ -861,6 +910,23 @@ impl HdlLetKindParse for HdlLetKind<Type> {
                 ModuleIOKind::Output(output),
             )
             .map(Self::IO),
+            LetFnKind::AddPlatformIO((add_platform_io,)) => {
+                if let Some(parsed_ty) = parsed_ty {
+                    return Err(Error::new_spanned(
+                        parsed_ty.1,
+                        "type annotation not allowed for instance",
+                    ));
+                }
+                let (m, dot_token) = unwrap_m_dot(m_dot, kind)?;
+                let paren_contents;
+                Ok(Self::AddPlatformIO(HdlLetKindAddPlatformIO {
+                    m,
+                    dot_token,
+                    add_platform_io,
+                    paren: parenthesized!(paren_contents in input),
+                    platform_io_builder: paren_contents.call(parse_single_fn_arg)?,
+                }))
+            }
             LetFnKind::Instance((instance,)) => {
                 if let Some(parsed_ty) = parsed_ty {
                     return Err(Error::new_spanned(
@@ -936,6 +1002,7 @@ impl HdlLetKindToTokens for HdlLetKind {
     fn ty_to_tokens(&self, tokens: &mut TokenStream) {
         match self {
             HdlLetKind::IO(v) => v.ty_to_tokens(tokens),
+            HdlLetKind::AddPlatformIO(v) => v.ty_to_tokens(tokens),
             HdlLetKind::Incomplete(v) => v.ty_to_tokens(tokens),
             HdlLetKind::Instance(v) => v.ty_to_tokens(tokens),
             HdlLetKind::RegBuilder(v) => v.ty_to_tokens(tokens),
@@ -947,6 +1014,7 @@ impl HdlLetKindToTokens for HdlLetKind {
     fn expr_to_tokens(&self, tokens: &mut TokenStream) {
         match self {
             HdlLetKind::IO(v) => v.expr_to_tokens(tokens),
+            HdlLetKind::AddPlatformIO(v) => v.expr_to_tokens(tokens),
             HdlLetKind::Incomplete(v) => v.expr_to_tokens(tokens),
             HdlLetKind::Instance(v) => v.expr_to_tokens(tokens),
             HdlLetKind::RegBuilder(v) => v.expr_to_tokens(tokens),
@@ -1149,7 +1217,7 @@ impl<T: ToString> ToTokens for ImplicitName<T> {
 struct Visitor<'a> {
     module_kind: Option<ModuleKind>,
     errors: Errors,
-    io: Vec<ModuleIO>,
+    io: ModuleIOOrAddPlatformIO,
     block_depth: usize,
     parsed_generics: &'a ParsedGenerics,
 }
@@ -1289,7 +1357,81 @@ impl Visitor<'_> {
             }),
             semi_token: hdl_let.semi_token,
         };
-        self.io.push(hdl_let);
+        match &mut self.io {
+            ModuleIOOrAddPlatformIO::ModuleIO(io) => io.push(hdl_let),
+            ModuleIOOrAddPlatformIO::AddPlatformIO => {
+                self.errors.error(
+                    kind,
+                    "can't have other inputs/outputs in a module using m.add_platform_io()",
+                );
+            }
+        }
+        let_stmt
+    }
+    fn process_hdl_let_add_platform_io(
+        &mut self,
+        hdl_let: HdlLet<HdlLetKindAddPlatformIO>,
+    ) -> Local {
+        let HdlLet {
+            mut attrs,
+            hdl_attr: _,
+            let_token,
+            mut_token,
+            ref name,
+            eq_token,
+            kind:
+                HdlLetKindAddPlatformIO {
+                    m,
+                    dot_token,
+                    add_platform_io,
+                    paren,
+                    platform_io_builder,
+                },
+            semi_token,
+        } = hdl_let;
+        let mut expr = quote! {#m #dot_token #add_platform_io};
+        paren.surround(&mut expr, |expr| {
+            let name_str = ImplicitName {
+                name,
+                span: name.span(),
+            };
+            quote_spanned! {name.span()=>
+                #name_str, #platform_io_builder
+            }
+            .to_tokens(expr);
+        });
+        self.require_module(add_platform_io);
+        attrs.push(parse_quote_spanned! {let_token.span=>
+            #[allow(unused_variables)]
+        });
+        let let_stmt = Local {
+            attrs,
+            let_token,
+            pat: parse_quote! { #mut_token #name },
+            init: Some(LocalInit {
+                eq_token,
+                expr: parse_quote! { #expr },
+                diverge: None,
+            }),
+            semi_token,
+        };
+        match &mut self.io {
+            ModuleIOOrAddPlatformIO::ModuleIO(io) => {
+                for io in io {
+                    self.errors.error(
+                        io.kind.kind,
+                        "can't have other inputs/outputs in a module using m.add_platform_io()",
+                    );
+                }
+            }
+            ModuleIOOrAddPlatformIO::AddPlatformIO => {
+                self.errors.error(
+                    add_platform_io,
+                    "can't use m.add_platform_io() more than once in a single module",
+                );
+            }
+        }
+        self.io = ModuleIOOrAddPlatformIO::AddPlatformIO;
         let_stmt
     }
     fn process_hdl_let_instance(&mut self, hdl_let: HdlLet<HdlLetKindInstance>) -> Local {
@@ -1510,6 +1652,7 @@ impl Visitor<'_> {
         }
         the_match! {
             IO => process_hdl_let_io,
+            AddPlatformIO => process_hdl_let_add_platform_io,
             Incomplete => process_hdl_let_incomplete,
             Instance => process_hdl_let_instance,
             RegBuilder => process_hdl_let_reg_builder,
@@ -1753,15 +1896,20 @@ impl Fold for Visitor<'_> {
     }
 }
 
+pub(crate) enum ModuleIOOrAddPlatformIO {
+    ModuleIO(Vec<ModuleIO>),
+    AddPlatformIO,
+}
+
 pub(crate) fn transform_body(
     module_kind: Option<ModuleKind>,
     mut body: Box<Block>,
     parsed_generics: &ParsedGenerics,
-) -> syn::Result<(Box<Block>, Vec<ModuleIO>)> {
+) -> syn::Result<(Box<Block>, ModuleIOOrAddPlatformIO)> {
     let mut visitor = Visitor {
         module_kind,
         errors: Errors::new(),
-        io: vec![],
+        io: ModuleIOOrAddPlatformIO::ModuleIO(vec![]),
         block_depth: 0,
         parsed_generics,
     };