Re: User Defined Attributes

[Max Samukha]

On Thursday, 8 November 2012 at 07:35:30 UTC, Jacob Carlborg 
wrote:
On 2012-11-07 23:20, Walter Bright wrote:

module bar;
@attribute struct foo
{
    string name;
}

@foo int a;

alias Tuple!(__traits(getAttributes, foo)) TP;

enum bool yes = hasAttribute!(bar.foo);

static if (yes)
    enum foo attr = getAttribute!(bar.foo);

The last two could actually be library functions.

Could you explain why it is impossible without complicating the 
current state of things? I gave it a quick try and it seems to 
work reasonably well (a proper implementation will be more 
involved due to compiler bugs and language issues irrelevant to 
this discussion):

// library that defines attribute accessors
module library;
import std.typetuple;

template TypeOf(alias symbol)
{
    alias typeof(symbol) TypeOf;
}

template indexOfAttribute(alias symbol, alias attrType)
{
    alias staticMap!(TypeOf, __traits(getAttributes, symbol)) 
attrTypes;
    enum indexOfAttribute = staticIndexOf!(attrTypes, attrType);
}

template hasAttribute(alias symbol, alias attrType)
{
    enum hasAttribute = indexOfAttribute!(symbol, attrType) != -1;
}

template getAttribute(alias symbol, alias attrType)
{
    alias TypeTuple!(__traits(getAttributes, symbol)) attrs;
    enum getAttribute = attrs[indexOfAttribute!(symbol, 
attrType)];
}

// module that defines a foo attribute
module a;

struct foo
{
    string name;
}

[foo("a's foo")] int a;

// an unrelated module that defines its own foo
module b;

import library;
import a;

struct foo
{
    string name;
}

[foo("b's foo")] int b;

static if (hasAttribute!(b, foo))
{
    alias getAttribute!(b, foo) t;
    static assert(getAttribute!(b, foo).name == "b's foo");
}

static if (hasAttribute!(a.a, a.foo))
    static assert(getAttribute!(a.a, a.foo).name == "a's foo");

void main()
{
}