How to please ra for a better attribute macro experience?

[cathaysia]

When I was writing the procedural macro, I noticed that ra was able to give me completion and highlighting when the property was parsed by syn to Ident. rustfmt can also format simple assignment expressions.
Such a macro would look like this:

#[transform(Person)]
struct People{}

ra Detect procedural macros again for better completion? Are you saying this is just my imagination?

If the answer is yes, then for complex attributes (such as slices), how can ra be completed, or rustfmt be able to format them?

[flodiebold]

Hi, it's rather unclear to me what you're asking. Could you give an example of where you expect to see completions and don't (if that's the question, I'm not sure)?

[cathaysia]

If I have a macro like this:

#[proc_macro_attribute]
pub fn convert_to(attr: TokenStream, input: TokenStream) -> TokenStream {
    let attr = parse_macro_input!(attr as syn::TypePath);
    let input: DeriveInput = parse_macro_input!(input as DeriveInput);
    let ident = input.ident.clone();

    quote! {
        #input

        impl From<#ident> for #attr {
            fn from(val: #ident)->Self{
                todo!();
            }
        }
    }
    .into()
}

then I can get code complete and higlight:

But if I have a macro like this:

#[proc_macro_attribute]
pub fn convert_to(_attr: TokenStream, input: TokenStream) -> TokenStream {
    let input: DeriveInput = parse_macro_input!(input as DeriveInput);

    quote! {
        #input
    }
    .into()
}

I can't get code complete and highlight:

But for complex types this will:

#[proc_macro_attribute]
pub fn convert_to(attr: TokenStream, input: TokenStream) -> TokenStream {
    let attr = parse_macro_input!(attr as syn::ExprArray);
    let input: DeriveInput = parse_macro_input!(input as DeriveInput);

    let mut res = quote! {};

    for attr in attr.elems {
        match attr {
            syn::Expr::Let(expr) => res.extend(quote! {
                #expr;
            }),
            _ => todo!(),
        }
    }

    quote! {
        #input

        fn fake_func(){
            #res
        }
    }
    .into()
}

Ok, it works also. sorry...

[flodiebold]

If I read your example right, your second example where the completion doesn't work doesn't use the attribute contents. The way that RA understands what the tokens inside the attribute parentheses mean is by looking at the expanded result. If e.g. the token in the macro input shows up in the macro expansion as a type name (with a span referring to the original token from the input), RA knows that it's a type and can show corresponding completions. If the token isn't used, it means nothing and RA can't provide completions.

For your last example, it's worth noting that RA can only provide completion if the macro actually expands. If you have something like #[convert_to([let abc = ])], syn will just return an error and the macro will fail to expand completely. In this situation RA is unable to provide completions. As soon as you write #[convert_to([let abc =a])] though, the macro can be expanded and RA knows what's going on. If you want completions to work perfectly, you can't rely on syn to parse the stuff inside the attribute since it doesn't do any error resilient parsing. (For attribute macros, this only goes for the attribute input, i.e. attr; for input, RA knows that it has to be a valid Rust item and so can fix up any syntax errors itself.)