macros can't interpolate impl items (or really parse them at all)

[durka]

This macro will never work:

macro_rules! foo {
    ($name:ident; $method:item) => (
        struct $name();
        impl $name {
            $method
        }
    )
}

Instead of reinterpreting $method as an impl item, the macro expander says it was expecting const, crate, default, extern, fn, pub, type, unsafe, or }.

Moreover :item isn't good enough for parsing impl items because it doesn't have a special case for self arguments.

Is the solution to create a new :implitem or to make :item more flexible in parsing and expansion?

[petrochenkov]

How we can solve this (I'm using functions as an example, but constants/types can be treated similarly):

• Introduce cover grammar for free functions and functions in traits/impls/extern-blocks. This should require little changes, these grammars are very similar.
• Use same structures in AST for functions and functions in traits/impls/extern-blocks.
• Report a semantic error in AST validation if something inappropriate was parsed by the cover grammar, e.g. self in a free function, or body in a foreign function. This should also greatly improve error messages.
• If we encounter an interpolated item (Nonterminal::NtItem) when trying to parse a traits/impls/extern-blocks item, accept it if it's a fn item and let AST validation care about everything else.

[steveklabnik]

Triage:

macro_rules! foo {
    ($name:ident; $method:item) => (
        struct $name();
        impl $name {
            $method
        }
    )
}

foo!(Name, fn foo() { println!("Hello world"); });

gives

error: no rules expected the token `,`
  --> src/lib.rs:10:10
   |
1  | macro_rules! foo {
   | ---------------- when calling this macro
...
10 | foo!(Name, fn foo() { println!("Hello world"); });
   |          ^ no rules expected this token in macro call

[petrochenkov]

The work on implementing #48137 (comment) has been steadily happening and #69366 almost completes it.