[refactor] hyperledger-iroha#3388: Make model! a module-level macro

Signed-off-by: Daniil Polyakov <arjentix@gmail.com>

Author: Arjentix

configs/peer/genesis.json

@@ -1,11 +1,5 @@
 #[cfg(not(feature = "std"))]
-use alloc::{
-    borrow::ToOwned as _,
-    format,
-    string::{String, ToString as _},
-    vec,
-    vec::Vec,
-};
+use alloc::{borrow::ToOwned as _, format, string::String, vec, vec::Vec};
 use core::{hash, marker::PhantomData, num::NonZeroU8, str::FromStr};
 
 use derive_more::{DebugCustom, Deref, DerefMut, Display};

crypto/src/hash.rs

@@ -11,7 +11,7 @@ license.workspace = true
 proc-macro = true
 
 [dependencies]
-syn = "1.0.107"
+syn = { version = "1.0.107", features = ["full", "extra-traits"] }
 quote = "1.0.23"
 proc-macro2 = "1.0.49"
 proc-macro-error = "1.0.4"

data_model/derive/Cargo.toml

@@ -200,14 +200,15 @@ pub fn impl_filter(event: &EventEnum) -> TokenStream {
     let filter_doc = format!(" Filter for {event_ident} entity");
 
     quote! {
-        iroha_data_model_derive::model! {
+        iroha_data_model_derive::model_single! {
             #[derive(Debug, Clone, PartialEq, Eq, Hash, derive_more::Constructor, Decode, Encode, Deserialize, Serialize, IntoSchema)]
             #[doc = #filter_doc]
             #vis struct #filter_ident #generics {
                 origin_filter: #fil_opt<#orig_fil<#imp_event>>,
                 event_filter: #fil_opt<#event_filter_ident>
             }
         }
+
         #[cfg(feature = "transparent_api")]
         impl #import_path::Filter for #filter_ident {
             type Event = #imp_event;
@@ -245,7 +246,7 @@ fn impl_event_filter(event: &EventEnum) -> proc_macro2::TokenStream {
     let event_filter_doc = format!(" Event filter for {event_ident} entity");
 
     quote! {
-        iroha_data_model_derive::model! {
+        iroha_data_model_derive::model_single! {
             #[derive(Debug, Clone, PartialEq, Eq, Hash, Decode, Encode, Deserialize, Serialize, IntoSchema)]
             #[allow(clippy::enum_variant_names, missing_docs)]
             #[doc = #event_filter_doc]

data_model/derive/src/filter.rs

@@ -1,29 +1,15 @@
 //! A crate containing various derive macros for `data_model`
 #![allow(clippy::std_instead_of_core)]
 
-mod api;
 mod filter;
 mod has_origin;
 mod id;
+mod model;
 mod partially_tagged;
 
 use proc_macro::TokenStream;
 use syn::parse_macro_input;
 
-struct Items(Vec<syn::DeriveInput>);
-
-impl syn::parse::Parse for Items {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let mut items = Vec::new();
-
-        while !input.is_empty() {
-            items.push(input.parse()?);
-        }
-
-        Ok(Self(items))
-    }
-}
-
 /// Macro which controls how to export item's API. The behaviour is controlled with `transparent_api`
 /// feature flag. If the flag is active, item's public fields will be exposed as public, however, if
 /// it's not active, item will be exposed as opaque, i.e. no fields will be visible. This enables
@@ -33,12 +19,16 @@ impl syn::parse::Parse for Items {
 /// Additionally, this macro will rewrite private items as public when `transparent_api` is active.
 /// If an item should remain private regardless of consumer library, just don't wrap it in this macro.
 ///
+/// Should be used only on public module named `model`.
+/// Macro will modify only structs, enums and unions. Other items will be left as is.
+///
 /// # Example
 ///
 /// ```rust
 /// use iroha_data_model_derive::model;
 ///
-/// model! {
+/// #[model]
+/// pub mod model {
 ///     pub struct DataModel1 {
 ///        pub item1: u32,
 ///        item2: u64
@@ -51,38 +41,42 @@ impl syn::parse::Parse for Items {
 /// }
 ///
 /// /* will produce:
-/// pub struct DataModel1 {
-///    #[cfg(feature = "transparent_api")]
-///    pub item1: u32,
-///    #[cfg(not(feature = "transparent_api"))]
-///    pub(crate) item1: u32,
-///    item2: u64
-/// }
+/// pub mod model {
+///     pub struct DataModel1 {
+///         #[cfg(feature = "transparent_api")]
+///         pub item1: u32,
+///         #[cfg(not(feature = "transparent_api"))]
+///         pub(crate) item1: u32,
+///         pub(super) item2: u64
+///     }
 ///
-/// #[cfg(not(feature = "transparent_api"))]
-/// pub struct DataModel2 {
-///    pub item1: u32,
-///    item2: u64
-/// }
+///     #[cfg(not(feature = "transparent_api"))]
+///     pub struct DataModel2 {
+///         pub item1: u32,
+///         pub(super) item2: u64
+///     }
 ///
-/// #[cfg(feature = "transparent_api")]
-/// struct DataModel2 {
-///    pub item1: u32,
-///    item2: u64
+///     #[cfg(feature = "transparent_api")]
+///     struct DataModel2 {
+///         pub item1: u32,
+///         pub(super) item2: u64
+///     }
 /// }
 /// */
 /// ```
-#[proc_macro]
+#[proc_macro_attribute]
 #[proc_macro_error::proc_macro_error]
-pub fn model(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as Items);
-    let mut items = Vec::new();
-
-    for item in input.0 {
-        items.push(api::process_item(item));
-    }
+pub fn model(_attr: TokenStream, input: TokenStream) -> TokenStream {
+    model::impl_model(&parse_macro_input!(input)).into()
+}
 
-    quote::quote! { #(#items)* }.into()
+/// Same as [`model`] macro, but only processes a single item.
+///
+/// You should prefer using [`model`] macro over this one.
+#[proc_macro]
+#[proc_macro_error::proc_macro_error]
+pub fn model_single(input: TokenStream) -> TokenStream {
+    model::process_item(parse_macro_input!(input)).into()
 }
 
 /// Derive macro for `Identifiable` trait which also automatically implements [`Ord`], [`Eq`],

data_model/derive/src/lib.rs

@@ -1,8 +1,49 @@
 use proc_macro2::TokenStream;
-use quote::quote;
+use proc_macro_error::abort;
+use quote::{quote, ToTokens};
 use syn::{parse_quote, Attribute};
 
-pub fn process_item(mut input: syn::DeriveInput) -> TokenStream {
+pub fn impl_model(input: &syn::ItemMod) -> TokenStream {
+    let syn::ItemMod {
+        attrs,
+        vis,
+        mod_token,
+        ident,
+        content,
+        semi,
+        ..
+    } = input;
+
+    let syn::Visibility::Public(vis_public) = vis else {
+        abort!(input, "The `model` attribute can only be used on public modules");
+    };
+    if ident != "model" {
+        abort!(
+            input,
+            "The `model` attribute can only be used on the `model` module"
+        );
+    }
+
+    let items_code = content.as_ref().map_or_else(Vec::new, |(_, items)| {
+        items.iter().cloned().map(process_item).collect()
+    });
+
+    quote! {
+        #(#attrs)*
+        #[allow(missing_docs)]
+        #vis_public #mod_token #ident {
+            #(#items_code)*
+        }#semi
+    }
+}
+
+pub fn process_item(item: syn::Item) -> TokenStream {
+    let mut input: syn::DeriveInput = match item {
+        syn::Item::Struct(item_struct) => item_struct.into(),
+        syn::Item::Enum(item_enum) => item_enum.into(),
+        syn::Item::Union(item_union) => item_union.into(),
+        other => return other.into_token_stream(),
+    };
     let vis = &input.vis;
 
     if matches!(vis, syn::Visibility::Public(_)) {

data_model/derive/src/api.rs data_model/derive/src/model.rs

@@ -7,5 +7,5 @@ error[E0603]: struct `QueryPayload` is private
 note: the struct `QueryPayload` is defined here
  --> $WORKSPACE/data_model/src/query.rs
   |
-  |         pub(crate) struct QueryPayload {
-  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |     pub use self::model::*;
+  |             ^^^^^^^^^^^^^^

data_model/derive/tests/ui_fail/transparent_api_private_item.stderr

@@ -14,12 +14,13 @@ use std::collections::{btree_map, btree_set};
 
 use derive_more::{Constructor, DebugCustom, Display};
 use getset::Getters;
-use iroha_data_model_derive::IdEqOrdHash;
+use iroha_data_model_derive::{model, IdEqOrdHash};
 use iroha_schema::IntoSchema;
 use parity_scale_codec::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 use serde_with::{DeserializeFromStr, SerializeDisplay};
 
+pub use self::model::*;
 use crate::{
     asset::{
         prelude::{Asset, AssetId},
@@ -28,7 +29,6 @@ use crate::{
     domain::prelude::*,
     expression::{ContainsAny, ContextValue, EvaluatesTo},
     metadata::Metadata,
-    model,
     role::{prelude::RoleId, RoleIds},
     HasMetadata, Identifiable, Name, ParseError, PublicKey, Registered,
 };
@@ -50,7 +50,10 @@ pub const TRANSACTION_SIGNATORIES_VALUE: &str = "transaction_signatories";
 /// The context value name for account signatories.
 pub const ACCOUNT_SIGNATORIES_VALUE: &str = "account_signatories";
 
-model! {
+#[model]
+pub mod model {
+    use super::*;
+
     /// Identification of an [`Account`]. Consists of Account name and Domain name.
     ///
     /// # Examples
@@ -60,7 +63,23 @@ model! {
     ///
     /// let id = "user@company".parse::<AccountId>().expect("Valid");
     /// ```
-    #[derive(DebugCustom, Display, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Constructor, Getters, Decode, Encode, DeserializeFromStr, SerializeDisplay, IntoSchema)]
+    #[derive(
+        DebugCustom,
+        Display,
+        Clone,
+        PartialEq,
+        Eq,
+        PartialOrd,
+        Ord,
+        Hash,
+        Constructor,
+        Getters,
+        Decode,
+        Encode,
+        DeserializeFromStr,
+        SerializeDisplay,
+        IntoSchema,
+    )]
     #[display(fmt = "{name}@{domain_id}")]
     #[debug(fmt = "{name}@{domain_id}")]
     #[getset(get = "pub")]
@@ -73,7 +92,18 @@ model! {
     }
 
     /// Account entity is an authority which is used to execute `Iroha Special Instructions`.
-    #[derive(Debug, Display, Clone, IdEqOrdHash, Getters, Decode, Encode, Deserialize, Serialize, IntoSchema)]
+    #[derive(
+        Debug,
+        Display,
+        Clone,
+        IdEqOrdHash,
+        Getters,
+        Decode,
+        Encode,
+        Deserialize,
+        Serialize,
+        IntoSchema,
+    )]
     #[allow(clippy::multiple_inherent_impl)]
     #[display(fmt = "({id})")] // TODO: Add more?
     #[ffi_type]
@@ -94,7 +124,9 @@ model! {
     }
 
     /// Builder which should be submitted in a transaction to create a new [`Account`]
-    #[derive(DebugCustom, Display, Clone, IdEqOrdHash, Decode, Encode, Deserialize, Serialize, IntoSchema)]
+    #[derive(
+        DebugCustom, Display, Clone, IdEqOrdHash, Decode, Encode, Deserialize, Serialize, IntoSchema,
+    )]
     #[display(fmt = "[{id}]")]
     #[debug(fmt = "[{id:?}] {{ signatories: {signatories:?}, metadata: {metadata} }}")]
     #[ffi_type]
@@ -108,7 +140,22 @@ model! {
     }
 
     /// Condition which checks if the account has the right signatures.
-    #[derive(Debug, Display, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Constructor, Decode, Encode, Deserialize, Serialize, IntoSchema)]
+    #[derive(
+        Debug,
+        Display,
+        Clone,
+        PartialEq,
+        Eq,
+        PartialOrd,
+        Ord,
+        Hash,
+        Constructor,
+        Decode,
+        Encode,
+        Deserialize,
+        Serialize,
+        IntoSchema,
+    )]
     #[serde(transparent)]
     #[repr(transparent)]
     // SAFETY: `SignatureCheckCondition` has no trap representation in `EvalueatesTo<bool>`