Only generic `impl` blocks get formatted in macros

[CAD97]

Ideally, both should be formatted.

Test:

> echo "m!(impl One {}); m!(impl<> Two {});" | rustup run nightly rustfmt
m!(impl One {});
m!(
    impl Two {}
);

> rustup run nightly rustfmt -Vv
rustfmt 1.7.0-nightly (88189a71 2024-01-19)

[tvsfx]

I ran into this bug while trying to write a wrapper declarative macro to allow formatting the input of a function-style procedural macro.

So the use case is as follows:

macro_rules! wrapper_macro {
    ($($inner:item),*) => {
        proc_macro!{$($inner)*}
    };
}

Unfortunately, one of my inputs to wrapper_macro is a non-generic impl block that I have no control over. My workaround is hence blocked by this bug.

EDIT:
explored a few more cases and produced a MWE (playground):

macro_rules! fmt_me {
    ($($inner:tt)*) => {
    };
}

// does not get formatted
fmt_me!(
impl Foo { fn f(&self) {} }
);
fmt_me!(
impl Bar for Baz { fn m(&self) {} }
);

// does get formatted
fmt_me!(
impl<T> Foo<T> { fn g(&self) {} }
mod test {
impl Foo { fn f(&self) {} }
}
);

[tvsfx]

I think I figured out the issue: the call parse_macro_arg(&mut parser) to the Rust parser here
parses an Impl Trait Type in the case of impl Foo, which I guess is a valid interpretation of the input, if not for the tokens that follow. In the case of impl<Generics> Foo, this interpretation is impossible, and a trait implementation is correctly parsed.

From the POV of rust-analyzer, I guess the problem is that parse_macro_arg allows backtracking when an Err is returned, but cannot be retried if an error occurs higher up the chain. This particular bug could be fixed by trying to parse an Item before a Ty, but this has to be carefully considered, since it might well introduce other bugs.

printf debugging details

This is the output I get for the macro argument in the first vs. the second case of this MWE:

macro_rules! fmt_me {
    ($($inner:tt)*) => {};
}

// does not work
fmt_me!(
impl Foo {
}
);

// works
fmt_me!(
impl<T> Foo<T> {
}
);

Some(Ty(Ty { id: NodeId(4294967040), kind: ImplTrait(NodeId(4294967040), [Trait(PolyTraitRef { bound_generic_params: [], modifiers: TraitBoundModifiers { constness: Never, asyncness: Normal, polarity: Positive }, trait_ref: TraitRef { path: Path { span: Span { lo: BytePos(83), hi: BytePos(86), ctxt: #0 }, segments: [PathSegment { ident: Foo#0, id: NodeId(4294967040), args: None }], tokens: None }, ref_id: NodeId(4294967040) }, span: Span { lo: BytePos(83), hi: BytePos(86), ctxt: #0 } })]), span: Span { lo: BytePos(78), hi: BytePos(86), ctxt: #0 }, tokens: None }))

Some(Item(Item { attrs: [], id: NodeId(4294967040), span: Span { lo: BytePos(113), hi: BytePos(131), ctxt: #0 }, vis: Visibility { kind: Inherited, span: Span { lo: BytePos(113), hi: BytePos(113), ctxt: #0 }, tokens: None }, kind: Impl(Impl { defaultness: Final, safety: Default, generics: Generics { params: [GenericParam { id: NodeId(4294967040), ident: T#0, attrs: [], bounds: [], is_placeholder: false, kind: Type { default: None }, colon_span: None }], where_clause: WhereClause { has_where_token: false, predicates: [], span: Span { lo: BytePos(127), hi: BytePos(127), ctxt: #0 } }, span: Span { lo: BytePos(117), hi: BytePos(120), ctxt: #0 } }, constness: No, polarity: "positive", of_trait: None, self_ty: Ty { id: NodeId(4294967040), kind: Path(None, Path { span: Span { lo: BytePos(121), hi: BytePos(127), ctxt: #0 }, segments: [PathSegment { ident: Foo#0, id: NodeId(4294967040), args: Some(AngleBracketed(AngleBracketedArgs { span: Span { lo: BytePos(124), hi: BytePos(127), ctxt: #0 }, args: [Arg(Type(Ty { id: NodeId(4294967040), kind: Path(None, Path { span: Span { lo: BytePos(125), hi: BytePos(126), ctxt: #0 }, segments: [PathSegment { ident: T#0, id: NodeId(4294967040), args: None }], tokens: None }), span: Span { lo: BytePos(125), hi: BytePos(126), ctxt: #0 }, tokens: None }))] })) }], tokens: None }), span: Span { lo: BytePos(121), hi: BytePos(127), ctxt: #0 }, tokens: None }, items: [] }), tokens: None }))