Another benefit of attribute macros requiring well-formed input is that, well, macros can assume we'll formed input, and so can the compiler's error recovery mechanism(s), and so can IDE syntax highlighting and intellisence.
With bang-style proc macros that take arbitrary token trees as input, it is provably impossible to implement any assistance (in the general case), whether that be as complicated as type aware autocomplete, or as simple as regex-based syntax highlighting. (proof)
With attribute macros, that (mostly) doesn't apply, specifically because the input has to be syntactically valid. Normal syntax highlighting works, and the standard compiler parser's error recovery can help catch and point out syntax errors. (Intellisence is still broken in the general case, but the common case where it works is much larger, due to the social pressure that if it looks like valid code it should translate to very similar valid code with minimal semantic difference.)
I consider it close to the biggest problem that current macros assume syntactically correct input. This allows them to use a parser that doesn't necessarily give good error messages on syntactically incorrect input, because the compiler already did that step. Changing this will cause nearly the entire ecosystem of proc macro attributes to go from a syntax error being the nice compiler error to
proc macro panicked: called Result::unwrap on an Err value: ParseErr with no span information.
All of this just so that attribute macros can be used instead of bang macros.
(And at one point closer to initial non-derive proc macros than now I was favorable towards this proposal. I no longer am due to the points iterated above and in the other posts.)
Proc macros aren't really meant to be full syntax replacements for Rust. For that, you're better off writing a separate file that you compile to Rust, potentially within a proc macro wrapper. (And I'm highly in favor of adding a proc-macro API for "give me a proper TokenStream for this path." This would make compile-to-Rust proc macro embedded languages much more ergonomic, and allow them to lean on Rust's error reporting to point into their own files.)