RFC for allowing macros in all ident positions

[Manishearth]

• Start Date: 2014-08-28
• RFC PR: (leave this empty)
• Rust Issue: (leave this empty)

Summary

Macros which resolve to idents should be usable in all positions that expect idents, including function/struct/enum names in definitions, et cetera.
Currently they can only be used as variable names.

Motivation

This will allow for creating better macros which resolve to functions. For example:

macro_rules! make_setter(
    ( $attr:ident ) => (
        fn concat_idents!(set_,$attr) (&self) -> u32 {
            self.$attr
        }
    );
)

can be created to generate setters just by calling make_setter(foo) (which will create set_foo())

Currently, using macros in this manner will lead to errors like

test.rs:1:17: 1:18 error: expected `(` but found `!`
test.rs:1 fn concat_idents!(Foo, Bar) () {
                          ^

See also: rust-lang/rust#13294

Detailed design

This will probably require converting ast::Ident to an enum allowing for a NamedIdent vs MacroIdent duality.

Drawbacks

None that I see

Alternatives

Suggestions welcome

Unresolved questions

I'm rather unsure about the implementation.

[SiegeLord]

I don't think blindly allowing macros everywhere is a good idea. For example, it might be cool to have syntax such as foo.bar!() which would pass foo to the macro bar! or something along those lines. This RFC, if implemented, would result in a much more useless interpretation.

[Manishearth]

@SiegeLord This isn't about blindly allowing them everywhere; it's about allowing them where we alow idents. But yes, this would break that sort of syntax. I personally don't see many uses for that syntax though -- and besides we can always write bar!(foo) (whereas here the workarounds involve rather ugly and complicated syntax extensions)

[SiegeLord]

I don't mind making macro writer write ugly code in exchange for the macro user being able to write beautiful code. It is irrelevant that you can write bar!(foo), the whole point of that that syntax (and method syntax in general) is that you don't have to.

A use case for that syntax involves multi-dimensional slices for matrices (matrix.sl![0..5, 3..5]), keyword arguments (my_type.function!(arg1 = 1, arg2 = "abc")) and probably many other useful sugarings.

[Manishearth]

The only workaround I know of is a syntext that's ugly to use

[brson]

@Manishearth thank you for the RFC. Right now we are not adding major new features to macros for fear that Rust metaprogramming is becoming a huge, unspeccable mess. Closing.