refactor(dan): template macro as an attribute macro

dan_layer/engine/tests/hello_world/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 
 [dependencies]
 tari_template_abi = { path = "../../../template_abi" }
-tari_template_macros = { path = "../macros" }
+tari_template_macros = { path = "../../../template_macros" }
 common = { path = "../common" }
 
 [profile.release]

dan_layer/engine/tests/hello_world/src/lib.rs

@@ -22,7 +22,8 @@
 
 use tari_template_macros::template;
 
-template! {
+#[template]
+mod hello_world {
     struct HelloWorld {}
 
     impl HelloWorld { 

dan_layer/engine/tests/macros/Cargo.toml → dan_layer/template_macros/Cargo.toml

@@ -10,7 +10,10 @@ edition = "2021"
 proc-macro = true
 
 [dependencies]
-tari_template_abi = { path = "../../../template_abi" }
+tari_template_abi = { path = "../template_abi" }
 syn = { version = "1.0.98", features = ["full"] }
 proc-macro2 = "1.0.42"
-quote = "1.0.20"
+quote = "1.0.20"
+
+[dev-dependencies]
+indoc = "1.0.6"

dan_layer/engine/tests/macros/src/ast.rs → dan_layer/template_macros/src/ast.rs

@@ -24,11 +24,13 @@ use syn::{
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
     token::Comma,
+    Error,
     FnArg,
     Ident,
     ImplItem,
     ImplItemMethod,
     ItemImpl,
+    ItemMod,
     ItemStruct,
     Result,
     ReturnType,
@@ -44,8 +46,32 @@ pub struct TemplateAst {
 
 impl Parse for TemplateAst {
     fn parse(input: ParseStream) -> Result<Self> {
-        let struct_section: ItemStruct = input.parse()?;
-        let impl_section = input.parse()?;
+        // parse the "mod" block
+        let module: ItemMod = input.parse()?;
+
+        // get the contents of the "mod" block
+        let items = match module.content {
+            Some((_, items)) => items,
+            None => return Err(Error::new(module.ident.span(), "empty module")),
+        };
+
+        // there should be two items: the "struct" and the "impl" blocks
+        if items.len() != 2 {
+            return Err(Error::new(module.ident.span(), "invalid number of module sections"));
+        }
+
+        // get the "struct" block
+        let struct_section = match &items[0] {
+            syn::Item::Struct(struct_item) => struct_item.clone(),
+            _ => return Err(Error::new(module.ident.span(), "the first section is not a 'struct'")),
+        };
+
+        // get the "impl" block
+        let impl_section = match &items[1] {
+            syn::Item::Impl(impl_item) => impl_item.clone(),
+            _ => return Err(Error::new(module.ident.span(), "the second section is not an 'impl'")),
+        };
+
         let template_name = struct_section.ident.clone();
 
         Ok(Self {

dan_layer/engine/tests/macros/src/lib.rs → dan_layer/template_macros/src/lib.rs

@@ -25,9 +25,9 @@ mod template;
 
 use proc_macro::TokenStream;
 
-#[proc_macro]
-pub fn template(input: TokenStream) -> TokenStream {
-    template::generate_template(proc_macro2::TokenStream::from(input))
+#[proc_macro_attribute]
+pub fn template(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    template::generate_template(proc_macro2::TokenStream::from(item))
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
 }

dan_layer/engine/tests/macros/src/template/abi.rs → dan_layer/template_macros/src/template/abi.rs

@@ -92,6 +92,7 @@ fn generate_abi_type(rust_type: &str) -> Expr {
 mod tests {
     use std::str::FromStr;
 
+    use indoc::indoc;
     use proc_macro2::TokenStream;
     use quote::quote;
     use syn::parse2;
@@ -101,9 +102,20 @@ mod tests {
 
     #[test]
     fn test_hello_world() {
-        let input = TokenStream::from_str(
-            "struct HelloWorld {} impl HelloWorld { pub fn greet() -> String { \"Hello World!\".to_string() } }",
-        )
+        let input = TokenStream::from_str(indoc! {"
+            mod foo {
+                struct Foo {}
+                impl Foo {
+                    pub fn no_args_function() -> String {
+                        \"Hello World!\".to_string()
+                    }
+                    pub fn some_args_function(a: i8, b: String) -> u32 {
+                        1_u32
+                    }
+                    pub fn no_return_function() {}  
+                } 
+            }
+        "})
         .unwrap();
 
         let ast = parse2::<TemplateAst>(input).unwrap();
@@ -112,16 +124,28 @@ mod tests {
 
         assert_code_eq(output, quote! {
             #[no_mangle]
-            pub extern "C" fn HelloWorld_abi() -> *mut u8 {
+            pub extern "C" fn Foo_abi() -> *mut u8 {
                 use ::tari_template_abi::{encode_with_len, FunctionDef, TemplateDef, Type};
 
                 let template = TemplateDef {
-                    template_name: "HelloWorld".to_string(),
-                    functions: vec![ FunctionDef {
-                        name: "greet".to_string(),
-                        arguments: vec![],
-                        output: Type::String,
-                    }],
+                    template_name: "Foo".to_string(),
+                    functions: vec![
+                        FunctionDef {
+                            name: "no_args_function".to_string(),
+                            arguments: vec![],
+                            output: Type::String,
+                        },
+                        FunctionDef {
+                            name: "some_args_function".to_string(),
+                            arguments: vec![Type::I8, Type::String],
+                            output: Type::U32,
+                        },
+                        FunctionDef {
+                            name: "no_return_function".to_string(),
+                            arguments: vec![],
+                            output: Type::Unit,
+                        }
+                    ],
                 };
 
                 let buf = encode_with_len(&template);

dan_layer/engine/tests/macros/src/template/dispatcher.rs → dan_layer/template_macros/src/template/dispatcher.rs

@@ -83,6 +83,7 @@ pub fn get_function_blocks(ast: &TemplateAst) -> Vec<Expr> {
 mod tests {
     use std::str::FromStr;
 
+    use indoc::indoc;
     use proc_macro2::TokenStream;
     use quote::quote;
     use syn::parse2;
@@ -91,9 +92,16 @@ mod tests {
 
     #[test]
     fn test_hello_world() {
-        let input = TokenStream::from_str(
-            "struct HelloWorld {} impl HelloWorld { pub fn greet() -> String { \"Hello World!\".to_string() } }",
-        )
+        let input = TokenStream::from_str(indoc! {"
+            mod hello_world {
+                struct HelloWorld {}
+                impl HelloWorld {
+                    pub fn greet() -> String {
+                        \"Hello World!\".to_string()
+                    }
+                } 
+            }
+        "})
         .unwrap();
 
         let ast = parse2::<TemplateAst>(input).unwrap();