fix item_as_dummy

Author: ModProg

CHANGELOG.md

@@ -4,8 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-<!-- <!-- ## [Unreleased] -->
-## [0.11.0] - 2024-01-27 -->
+## [Unreleased]
+### Fixed
+- fix `item_as_dummy` for attribute macros
+
+## [0.11.0] - 2024-01-27
 ### Added
 - `{Function,Attribute,Derive}MacroHandler`,
 

examples/macro/src/lib.rs

@@ -11,6 +11,12 @@ pub fn attr_item_as_dummy(_input: TokenStream, _item: TokenStream) -> SilentResu
     Err(SilentError)
 }
 
+#[manyhow(item_as_dummy)]
+#[proc_macro_attribute]
+pub fn attr_item_as_dummy_ok(_input: TokenStream, _item: TokenStream) -> TokenStream2 {
+    quote!()
+}
+
 #[manyhow()]
 #[proc_macro_attribute]
 pub fn attr_no_dummy(_input: TokenStream, _item: TokenStream) -> SilentResult {

examples/macro/tests/test.rs

@@ -6,6 +6,9 @@ fn attr() {
     struct ItemAsDummy;
     _ = ItemAsDummy;
 
+    #[attr_item_as_dummy_ok] // does not conflict with above
+    struct ItemAsDummy;
+
     #[attr_no_dummy]
     struct ItemAsDummy; // does not conflict with above
 

src/lib.rs

@@ -36,7 +36,7 @@
 //! ```
 //!
 //! # Using the `#[manyhow]` macro
-//! To activate the error hadling, just add [`#[manyhow]`](manyhow) above any
+//! To activate the error handling, just add [`#[manyhow]`](manyhow) above any
 //! proc-macro implementation, reducing the above example to:
 //!
 //! ```
@@ -70,8 +70,8 @@
 //! See [Without macros](#without-macros) to see what this expands to under the
 //! hood.
 //!
-//! You can also use the `#[manyhow]` attrubutes on a use statement, useful when
-//! moving your proc-macro implementations in seperate modules.
+//! You can also use the `#[manyhow]` attributes on a use statement, useful when
+//! moving your proc-macro implementations in separate modules.
 //!
 //! ```
 //! # use quote::quote;
@@ -98,7 +98,7 @@
 //!
 //! A proc macro function marked as `#[manyhow]` can take and return any
 //! [`TokenStream`](AnyTokenStream), and can also return `Result<TokenStream,
-//! E>` where `E` implments [`ToTokensError`]. As additional parameters a
+//! E>` where `E` implements [`ToTokensError`]. As additional parameters a
 //! [dummy](#dummy-mut-tokenstream) and/or [emitter](#emitter-mut-emitter) can
 //! be specified.
 //!
@@ -226,7 +226,7 @@
 //!   macro.
 //! - `syn`/`syn2` **default** Enables errors for [`syn` 2.x](https://docs.rs/syn/latest/syn/).
 //! - `syn1` Enables errors for [`syn` 1.x](https://docs.rs/syn/1.0.109/syn/index.html).
-//! - `darling` Enables erros for [`darling`](https://docs.rs/darling/latest/index.html).
+//! - `darling` Enables errors for [`darling`](https://docs.rs/darling/latest/index.html).
 
 #[cfg(feature = "macros")]
 pub use macros::manyhow;
@@ -290,9 +290,13 @@ macro_rules! __macro_handler {
             )+ $($dummy,)? implementation)
             {
                 Err(tokens) => tokens.into(),
-                Ok((output, mut tokens)) => {
+                Ok((output, mut tokens, mut dummy)) => {
                     match (&$crate::__private::WhatType::from(&output)).manyhow_try(output) {
-                        Err(error) => (&$crate::__private::WhatType::from(&error)).manyhow_to_tokens(error, &mut tokens),
+                        Err(error) => {
+                            dummy.extend(tokens);
+                            tokens = dummy;
+                            (&$crate::__private::WhatType::from(&error)).manyhow_to_tokens(error, &mut tokens);
+                        },
                         Ok(output) => (&$crate::__private::WhatType::from(&output)).manyhow_to_tokens(output, &mut tokens),
                     };
                     tokens.into()
@@ -762,7 +766,7 @@ macro_rules! macro_input {
         ///
         /// Trait is implemented for any [`function`](FnOnce), taking in
         #[doc = concat!($token_streams, ".")]
-        /// Additionally they can take optionally in any order a [`&mut
+        /// Additionally, they can take optionally in any order a [`&mut
         /// Emitter`](Emitter) which allows emitting errors without returning early. And
         /// a `&mut TokenStream` to return a dummy `TokenStream` on failure.
         ///

src/parse_to_tokens.rs

@@ -144,7 +144,7 @@ macro_rules! transparent_handlers {
             $($input: Result<$Input, TokenStream>,)*
             $($dummy: Option<impl AnyTokenStream>,)?
             body: impl $MacroInput<Function, $($Input = $Input,)* Dummy = Dummy, Output = Output>,
-        ) -> Result<(Output, TokenStream), TokenStream> {
+        ) -> Result<(Output, TokenStream, TokenStream), TokenStream> {
             // use $crate::ToTokensError as _;
             #[allow(unused)]
             let mut dummy = TokenStream::new();
@@ -157,12 +157,12 @@ macro_rules! transparent_handlers {
                     return Err(dummy);
                 }
             };)*
-            let mut tokens = dummy.into();
+            let mut dummy = dummy.into();
             let mut emitter = Emitter::new();
-            let output = body.call($($input,)+ &mut tokens, &mut emitter);
-            let mut tokens = tokens.into();
+            let output = body.call($($input,)+ &mut dummy, &mut emitter);
+            let mut tokens = TokenStream::new();
             emitter.to_tokens(&mut tokens);
-            Ok((output, tokens))
+            Ok((output, tokens, dummy.into()))
         }
     };
 }