User Defined Attributes

[Gor Gyolchanyan]

On Tuesday, 6 November 2012 at 14:05:46 UTC, Adam D. Ruppe wrote:
> On Tuesday, 6 November 2012 at 13:55:49 UTC, Rory McGuire wrote:
>> You can put the attribute on the function.
>
> Yeah, but that's an awfully roundabout way to add an attribute 
> to the parameter...
>
> if it went on func params:
> void foo([Hint("this does something")] string something) {}
>
> otherwise we'd have to do something like
>
> [ParamHint("something", "this does something")] void foo(string 
> something) {}
>
>
> Which isn't really ahead from the old hack of
>
> enum attr_foo_someting = Hint("");
>
> and has similar problems in matching names. It's a little 
> better but not as good as it could be.

What if the data in the attribute needs to be specific to the 
symbol on which the attribute is set on? Can you query the symbol 
from inside the attribute?
What if the attribute needs to change the symbol being defined?
For instance (using commonly desired syntax):

@flags enum A { ... }

the "flags" attribute would replace the declaraction of A with 
another enum declaration with the same name and same members, but 
with replaced initialization and would static assert(false, 
"flags enum can't have initializers") if any initializers are 
given.

The existing "[data] declaration" is one thing. It adds 
compile-time data to symbols, which is very very important, but 
it's not the only thing that is needed. What I described above is 
not quite an attribute, but an annotation. The semantics of 
attributes as Walter made them is perfect. The annotation should 
be  defined like so:

template myAnnotation(alias symbol, annot_args...)
{
     // ...
     ["myAnnoration adds this attribute"] alias symbol 
myAnnotation; // or alias anything else if a change in necessary.
}

@myAnnotation(arg1, arg2, arg3) class Declaration
{
}

here the "symbol" is passed to the template as the first 
parameter and the parameters in the parentheses are passes after 
it. It's basically a thin syntactic sugar over some manual (and 
very ugly) manual template instantiations (and mixins), so it 
doesn't add anything new.

Annotations then become a way to statically replace declarations.
This would be perfect to replace

Scoped!MyClass mc;

with:

@scoped MyClass mc;

Which looks quite like a very beautiful built-in syntax, but is 
actually a library solution.

IMHO, Attributes as they are should stay, but annotations should 
be added.

P.S. Thank you, Walter very very much for making attributes!!! :-)