WIP adding Platform

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