__traits(getDelegate, ...)

[Steven Schveighoffer]

I wanted to put forth again a proposal I had for getting a delegate to an  
overloaded function.  Only because I think it's relevant to the latest  
property debate.

When getting the address of a delegate, it's as simple as:

struct S
{
    void foo(int x) {}
}

S s;
auto dg = &s.foo; // delegate obtained

However, if foo is overloaded, this becomes more complex:

struct S
{
    void foo(int x) {}
    void foo(string s) {}
}

S s;
auto dg = &s.foo; // which one?  Compiler chooses!

Turns out, it's somewhat possible to specify, but it can be  
painful/uintuitive:

auto dg = cast(void delegate(string))&s.foo; // oops, what if I use the  
wrong delegate signature, or S.foo is changed later!

How about getting a delegate using __traits?

auto dg = __traits(getDelegate, s.foo, string);

Maybe not quite as pretty as &s.foo, but at least allows you to form a  
good expression without a cast.

Now, why is this relevant now?  It could be useful for properties as  
well.  It could allow obtaining a delegate to a property (arguably a very  
rare occurrence), where the current property proposal uses a funky  
parentheses technique for it (which seems unintuitive for a C expression  
to be changed by adding parentheses).

Full proposal:

__traits(getDelegate, symbol, arg1, arg2, ..., argN)

The args are optional, only needed if overloads exist.  If overloads  
exist, args MUST be specified (to protect against future changes).  In the  
special case where one of the overloads has no arguments, void must be  
specified for that overload.

Rules/syntax subject to debate.

Destroy!

-Steve