[refactor] #3934: Migrate iroha_smart_contract_derive, iroha_executor_derive and iroha_trigger_derive to syn 2.0

smart_contract/derive/Cargo.toml

@@ -14,6 +14,9 @@ workspace = true
 proc-macro = true
 
 [dependencies]
-syn.workspace = true
-quote.workspace = true
-proc-macro2.workspace = true
+iroha_macro_utils = { workspace = true }
+
+syn2 = { workspace = true }
+manyhow = { workspace = true }
+quote = { workspace = true }
+proc-macro2 = { workspace = true }

smart_contract/derive/src/entrypoint.rs

@@ -1,26 +1,32 @@
 //! Macro for writing smart contract entrypoint
 
-use proc_macro::TokenStream;
+#![allow(clippy::str_to_string)]
+
+use iroha_macro_utils::Emitter;
+use manyhow::emit;
+use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, parse_quote};
+use syn2::parse_quote;
 
 mod export {
     pub const SMART_CONTRACT_MAIN: &str = "_iroha_smart_contract_main";
 }
 
 #[allow(clippy::needless_pass_by_value)]
-pub fn impl_entrypoint(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let syn::ItemFn {
+pub fn impl_entrypoint(emitter: &mut Emitter, item: syn2::ItemFn) -> TokenStream {
+    let syn2::ItemFn {
         attrs,
         vis,
         sig,
         mut block,
-    } = parse_macro_input!(item);
+    } = item;
 
-    assert!(
-        syn::ReturnType::Default == sig.output,
-        "Smart contract `main()` function must not have a return type"
-    );
+    if sig.output != syn2::ReturnType::Default {
+        emit!(
+            emitter,
+            "Smart contract entrypoint must not have a return type"
+        );
+    }
 
     let fn_name = &sig.ident;
 
@@ -33,7 +39,8 @@ pub fn impl_entrypoint(_attr: TokenStream, item: TokenStream) -> TokenStream {
         ),
     );
 
-    let main_fn_name = syn::Ident::new(export::SMART_CONTRACT_MAIN, proc_macro2::Span::call_site());
+    let main_fn_name =
+        syn2::Ident::new(export::SMART_CONTRACT_MAIN, proc_macro2::Span::call_site());
 
     quote! {
         /// Smart contract entrypoint
@@ -51,5 +58,4 @@ pub fn impl_entrypoint(_attr: TokenStream, item: TokenStream) -> TokenStream {
         #vis #sig
         #block
     }
-    .into()
 }

smart_contract/derive/src/lib.rs

@@ -1,6 +1,8 @@
 //! Macros for writing smart contracts.
 
-use proc_macro::TokenStream;
+use iroha_macro_utils::Emitter;
+use manyhow::{emit, manyhow};
+use proc_macro2::TokenStream;
 
 mod entrypoint;
 
@@ -23,7 +25,23 @@ mod entrypoint;
 ///    todo!()
 /// }
 /// ```
+#[manyhow]
 #[proc_macro_attribute]
 pub fn main(attr: TokenStream, item: TokenStream) -> TokenStream {
-    entrypoint::impl_entrypoint(attr, item)
+    let mut emitter = Emitter::new();
+
+    if !attr.is_empty() {
+        emit!(
+            emitter,
+            "Smart contract entrypoint does not accept attributes"
+        );
+    }
+
+    let Some(item) = emitter.handle(syn2::parse2(item)) else {
+        return emitter.finish_token_stream();
+    };
+
+    let result = entrypoint::impl_entrypoint(&mut emitter, item);
+
+    emitter.finish_token_stream_with(result)
 }

smart_contract/executor/derive/Cargo.toml

@@ -15,10 +15,10 @@ workspace = true
 proc-macro = true
 
 [dependencies]
-iroha_macro_utils.workspace = true
-syn = { workspace = true, features = ["full", "derive"] }
+iroha_macro_utils = { workspace = true }
+
 syn2 = { workspace = true, features = ["full", "derive"] }
-quote.workspace = true
-proc-macro2.workspace = true
-manyhow.workspace = true
-darling.workspace = true
+quote = { workspace = true }
+proc-macro2 = { workspace = true }
+manyhow = { workspace = true }
+darling = { workspace = true }

smart_contract/executor/derive/src/conversion.rs

@@ -1,76 +1,66 @@
 //! Module with conversion derive macros implementation
 
-use super::*;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn2::DeriveInput;
 
 /// [`derive_ref_into_asset_owner`](crate::derive_ref_into_asset_owner) macro implementation
-pub fn impl_derive_ref_into_asset_owner(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
+pub fn impl_derive_ref_into_asset_owner(input: &DeriveInput) -> TokenStream {
     impl_from(
         &input.ident,
         &input.generics,
-        &syn::parse_quote!(::iroha_executor::permission::asset::Owner),
-        &syn::parse_quote!(asset_id),
+        &syn2::parse_quote!(::iroha_executor::permission::asset::Owner),
+        &syn2::parse_quote!(asset_id),
     )
-    .into()
 }
 
 /// [`derive_ref_into_asset_definition_creator`](crate::derive_ref_into_asset_definition_creator)
 /// macro implementation
-pub fn impl_derive_ref_into_asset_definition_owner(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
+pub fn impl_derive_ref_into_asset_definition_owner(input: &DeriveInput) -> TokenStream {
     impl_from(
         &input.ident,
         &input.generics,
-        &syn::parse_quote!(::iroha_executor::permission::asset_definition::Owner),
-        &syn::parse_quote!(asset_definition_id),
+        &syn2::parse_quote!(::iroha_executor::permission::asset_definition::Owner),
+        &syn2::parse_quote!(asset_definition_id),
     )
-    .into()
 }
 
 /// [`derive_ref_into_account_owner`](crate::derive_ref_into_account_owner) macro implementation
-pub fn impl_derive_ref_into_account_owner(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
+pub fn impl_derive_ref_into_account_owner(input: &DeriveInput) -> TokenStream {
     impl_from(
         &input.ident,
         &input.generics,
-        &syn::parse_quote!(::iroha_executor::permission::account::Owner),
-        &syn::parse_quote!(account_id),
+        &syn2::parse_quote!(::iroha_executor::permission::account::Owner),
+        &syn2::parse_quote!(account_id),
     )
-    .into()
 }
 
 /// [`derive_ref_into_domain_owner`](crate::derive_ref_into_domain_owner) macro implementation
-pub fn impl_derive_ref_into_domain_owner(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-
+pub fn impl_derive_ref_into_domain_owner(input: &DeriveInput) -> TokenStream {
     impl_from(
         &input.ident,
         &input.generics,
-        &syn::parse_quote!(::iroha_executor::permission::domain::Owner),
-        &syn::parse_quote!(domain_id),
+        &syn2::parse_quote!(::iroha_executor::permission::domain::Owner),
+        &syn2::parse_quote!(domain_id),
     )
-    .into()
 }
 
 fn impl_from(
-    ident: &syn::Ident,
-    generics: &syn::Generics,
-    pass_condition_type: &syn::Type,
-    field: &syn::Ident,
-) -> proc_macro2::TokenStream {
+    ident: &syn2::Ident,
+    generics: &syn2::Generics,
+    pass_condition_type: &syn2::Type,
+    field: &syn2::Ident,
+) -> TokenStream {
     use quote::ToTokens;
 
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
-    let mut generics: proc_macro2::TokenStream = syn::parse_str("<'token, ").unwrap();
+    let mut generics: TokenStream = syn2::parse_str("<'token, ").unwrap();
 
     let impl_generics_tokens = impl_generics.into_token_stream();
     if impl_generics_tokens.is_empty() {
         generics.extend(core::iter::once(proc_macro2::TokenTree::Punct(
-            syn::parse_str(">").unwrap(),
+            syn2::parse_str(">").unwrap(),
         )));
     } else {
         generics.extend(impl_generics_tokens.into_iter().skip(1));