Fix some macro bugs for 1.41.1

Author: sanket1729

src/descriptor/mod.rs

@@ -653,7 +653,7 @@ impl Descriptor<DescriptorPublicKey> {
 
 impl_from_tree!(
     Descriptor<Pk>,
-    /// Parse an expression tree into a descriptor
+    /// Parse an expression tree into a descriptor.
     fn from_tree(top: &expression::Tree) -> Result<Descriptor<Pk>, Error> {
         Ok(match (top.name, top.args.len() as u32) {
             ("pkh", 1) => Descriptor::Pkh(Pkh::from_tree(top)?),

src/descriptor/tr.rs

@@ -388,10 +388,11 @@ where
     }
 }
 
+#[rustfmt::skip]
 impl_block_str!(
     Tr<Pk>,
     // Helper function to parse taproot script path
-    fn parse_tr_script_spend(tree: &expression::Tree) -> Result<TapTree<Pk>, Error> {
+    fn parse_tr_script_spend(tree: &expression::Tree,) -> Result<TapTree<Pk>, Error> {
         match tree {
             expression::Tree { name, args } if !name.is_empty() && args.is_empty() => {
                 let script = Miniscript::<Pk, Tap>::from_str(name)?;

src/macros.rs

@@ -19,7 +19,11 @@ macro_rules! policy_str {
 /// Macro for implementing FromTree trait. This avoids copying all the Pk::Associated type bounds
 /// throughout the codebase.
 macro_rules! impl_from_tree {
-    ($(;$gen:ident; $gen_con:ident, )* $name: ty, $fn: item) => {
+    ($(;$gen:ident; $gen_con:ident, )* $name: ty,
+        $(#[$meta:meta])*
+        fn $fn:ident ( $($arg:ident : $type:ty),* ) -> $ret:ty
+        $body:block
+    ) => {
         impl<Pk $(, $gen)*> $crate::expression::FromTree for $name
         where
             Pk: MiniscriptKey + core::str::FromStr,
@@ -28,15 +32,24 @@ macro_rules! impl_from_tree {
             <<Pk as MiniscriptKey>::Hash as core::str::FromStr>::Err: $crate::prelude::ToString,
             $($gen : $gen_con,)*
             {
-                $fn
+
+                $(#[$meta])*
+                fn $fn($($arg: $type)* ) -> $ret {
+                    $body
+                }
             }
     };
 }
 
 /// Macro for implementing FromTree trait. This avoids copying all the Pk::Associated type bounds
 /// throughout the codebase.
 macro_rules! impl_from_str {
-    ($(;$gen:ident; $gen_con:ident, )* $name: ty $(, $it: item)*) => {
+    ($(;$gen:ident; $gen_con:ident, )* $name: ty,
+        type Err = $err_ty:ty;,
+        $(#[$meta:meta])*
+        fn $fn:ident ( $($arg:ident : $type:ty),* ) -> $ret:ty
+        $body:block
+    ) => {
         impl<Pk $(, $gen)*> core::str::FromStr for $name
         where
             Pk: MiniscriptKey + core::str::FromStr,
@@ -45,15 +58,24 @@ macro_rules! impl_from_str {
             <<Pk as MiniscriptKey>::Hash as core::str::FromStr>::Err: $crate::prelude::ToString,
             $($gen : $gen_con,)*
             {
-                $($it)*
+                type Err = $err_ty;
+
+                $(#[$meta])*
+                fn $fn($($arg: $type)* ) -> $ret {
+                    $body
+                }
             }
     };
 }
 
 /// Macro for implementing FromTree trait. This avoids copying all the Pk::Associated type bounds
 /// throughout the codebase.
 macro_rules! impl_block_str {
-    ($(;$gen:ident; $gen_con:ident, )* $name: ty $(, $it: item)*) => {
+    ($(;$gen:ident; $gen_con:ident, )* $name: ty,
+        $(#[$meta:meta])*
+        $v:vis fn $fn:ident ( $($arg:ident : $type:ty, )* ) -> $ret:ty
+        $body:block
+    ) => {
         impl<Pk $(, $gen)*> $name
         where
             Pk: MiniscriptKey + std::str::FromStr,
@@ -62,7 +84,10 @@ macro_rules! impl_block_str {
             <<Pk as MiniscriptKey>::Hash as std::str::FromStr>::Err: std::string::ToString,
             $($gen : $gen_con,)*
             {
-                $($it)*
+                $(#[$meta])*
+                $v fn $fn($($arg: $type,)* ) -> $ret {
+                    $body
+                }
             }
     };
 }

src/miniscript/mod.rs

@@ -350,7 +350,7 @@ impl_block_str!(
     /// Some of the analysis guarantees of miniscript are lost when dealing with
     /// insane scripts. In general, in a multi-party setting users should only
     /// accept sane scripts.
-    pub fn from_str_insane(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>
+    pub fn from_str_insane(s: &str,) -> Result<Miniscript<Pk, Ctx>, Error>
     {
         // This checks for invalid ASCII chars
         let top = expression::Tree::from_str(s)?;

src/policy/concrete.rs

@@ -698,14 +698,14 @@ impl_from_str!(
 
 serde_string_impl_pk!(Policy, "a miniscript concrete policy");
 
+#[rustfmt::skip]
 impl_block_str!(
     Policy<Pk>,
     /// Helper function for `from_tree` to parse subexpressions with
     /// names of the form x@y
-    fn from_tree_prob(
-        top: &expression::Tree,
-        allow_prob: bool,
-    ) -> Result<(usize, Policy<Pk>), Error> {
+    fn from_tree_prob(top: &expression::Tree, allow_prob: bool,)
+        -> Result<(usize, Policy<Pk>), Error>
+    {
         let frag_prob;
         let frag_name;
         let mut name_split = top.name.split('@');