feat: Pass attributes through #[test] macro

This is done by recursively parsing the attributes, filtering out the 
`#[ignore]` macro. This should also make it fairly trivial to add additional 
macros, such as `#[should_ignore]`.

There is a fair amount of complexity added to the macro with this change,
but on the other hand, it also succeeds in generating only the necessary code.
You win some, you lose some.

Author: skogseth

crates/libtest2/src/lib.rs

@@ -60,7 +60,6 @@ pub mod _private {
     pub use libtest2_harness::TestKind;
 
     pub use crate::_main_parse as main_parse;
-    pub use crate::_parse_ignore as parse_ignore;
     pub use crate::_test_parse as test_parse;
     pub use crate::case::DynCase;
 }

crates/libtest2/src/macros.rs

@@ -13,22 +13,115 @@ macro_rules! _main_parse {
 }
 
 #[macro_export]
-macro_rules! _parse_ignore {
-    (ignore) => {
-        ::std::option::Option::<&'static str>::None
+#[allow(clippy::crate_in_macro_def)] // accessing item defined by `_main_parse`
+macro_rules! _test_parse {
+    // Entry point
+    (#[test] $(#[$($attr:tt)+])* fn $name:ident $($item:tt)*) => {
+        $crate::_private::test_parse! {
+            name=$name
+            body=[$($item)*]
+            unparsed_attrs=[$(#[$($attr)+])*]
+            parsed_attrs=[]
+        }
     };
-    (ignore = $reason:expr) => {
-        ::std::option::Option::<&'static str>::Some($reason)
+
+    // Recursively handle attributes
+    (name=$name:ident body=[$($item:tt)*] unparsed_attrs=[] parsed_attrs=[$(#[$parsed_attr:meta])*] $(ignore=$state:expr)?) => {
+        $crate::_private::test_parse! {
+            name=$name
+            body=[$($item)*]
+            attrs=[$(#[$parsed_attr])*]
+            $(ignore=$state)?
+        }
     };
-    ($($attr:tt)*) => {
-        compile_error!(concat!("unknown attribute '", stringify!($($attr)*), "'"));
+    (name=$name:ident body=[$($item:tt)*] unparsed_attrs=[#[ignore] $(#[$($unparsed_attr:tt)+])*] parsed_attrs=[$(#[$parsed_attr:meta])*] $(ignore=$state:expr)?) => {
+        $crate::_private::test_parse! {
+            name=$name
+            body=[$($item)*]
+            unparsed_attrs=[$(#[$($unparsed_attr)*])*]
+            parsed_attrs=[$(#[$parsed_attr])*]
+            ignore=()
+        }
+    };
+    (name=$name:ident body=[$($item:tt)*] unparsed_attrs=[#[ignore = $reason:literal] $(#[$($unparsed_attr:tt)+])*] parsed_attrs=[$(#[$parsed_attr:meta])*] $(ignore=$state:expr)?) => {
+        $crate::_private::test_parse! {
+            name=$name
+            body=[$($item)*]
+            unparsed_attrs=[$(#[$($unparsed_attr)*])*]
+            parsed_attrs=[$(#[$parsed_attr])*]
+            ignore=$reason
+        }
+    };
+    (name=$name:ident body=[$($item:tt)*] unparsed_attrs=[#[$($attr:tt)+] $(#[$($unparsed_attr:tt)+])*] parsed_attrs=[$(#[$parsed_attr:meta])*] $(ignore=$state:expr)?) => {
+        $crate::_private::test_parse! {
+            name=$name
+            body=[$($item)*]
+            unparsed_attrs=[$(#[$($unparsed_attr)*])*]
+            parsed_attrs=[#[$($attr)* $(#[$($parsed_attr)*])*]]
+            $(ignore=$state)?
+        }
     };
-}
 
-#[macro_export]
-#[allow(clippy::crate_in_macro_def)] // accessing item defined by `_main_parse`
-macro_rules! _test_parse {
-    (#[test] $(#[$($attr:tt)*])* fn $name:ident $($item:tt)*) => {
+    // End result
+    (name=$name:ident body=[$($item:tt)*] attrs=[$(#[$attr:meta])*]) => {
+        #[allow(non_camel_case_types)]
+        struct $name;
+
+        impl $crate::_private::Case for $name {
+            fn name(&self) -> &str {
+                $crate::_private::push!(crate::TESTS, _: $crate::_private::DynCase = $crate::_private::DynCase(&$name));
+
+                stringify!($name)
+            }
+            fn kind(&self) -> $crate::_private::TestKind {
+                Default::default()
+            }
+            fn source(&self) -> Option<&$crate::_private::Source> {
+                None
+            }
+            fn exclusive(&self, _: &$crate::TestContext) -> bool {
+                false
+            }
+
+            fn run(&self, context: &$crate::TestContext) -> $crate::RunResult {
+                $(#[$attr])*
+                fn run $($item)*
+
+                run(context)
+            }
+        }
+    };
+    (name=$name:ident body=[$($item:tt)*] attrs=[$(#[$attr:meta])*] ignore=$reason:literal) => {
+        #[allow(non_camel_case_types)]
+        struct $name;
+
+        impl $crate::_private::Case for $name {
+            fn name(&self) -> &str {
+                $crate::_private::push!(crate::TESTS, _: $crate::_private::DynCase = $crate::_private::DynCase(&$name));
+
+                stringify!($name)
+            }
+            fn kind(&self) -> $crate::_private::TestKind {
+                Default::default()
+            }
+            fn source(&self) -> Option<&$crate::_private::Source> {
+                None
+            }
+            fn exclusive(&self, _: &$crate::TestContext) -> bool {
+                false
+            }
+
+            fn run(&self, context: &$crate::TestContext) -> $crate::RunResult {
+                $(#[$attr])*
+                fn run $($item)*
+
+                context.ignore_for($reason)?;
+
+                run(context)
+            }
+        }
+    };
+    (name=$name:ident body=[$($item:tt)*] attrs=[$(#[$attr:meta])*] ignore=$unused:expr) => {
         #[allow(non_camel_case_types)]
         struct $name;
 
@@ -49,14 +142,10 @@ macro_rules! _test_parse {
             }
 
             fn run(&self, context: &$crate::TestContext) -> $crate::RunResult {
+                $(#[$attr])*
                 fn run $($item)*
 
-                $(
-                    match $crate::_private::parse_ignore!($($attr)*) {
-                        ::std::option::Option::None => context.ignore()?,
-                        ::std::option::Option::Some(reason) => context.ignore_for(reason)?,
-                    }
-                )*
+                context.ignore()?;
 
                 use $crate::IntoRunResult;
                 let result = run(context);