Can't instantiate template from __traits(getOverloads, ...)

[TurkeyMan]

struct Test
{
    void fn(int) {}
    void fn()(float) {} // template overload
}

void test()
{
    Test t;
    void delegate(int) fnptr = &__traits(getOverloads, t, "fn", true)[0];
    void delegate(float) tfnptr = &__traits(getOverloads, t, "fn", true)[1]!(); // error : semicolon needed to end declaration of `tfnptr` instead of `!`

    // you can see above when we try and instantiate the template given by getOverloads, it seems the grammar just doesn't accept it!

    // ...but really, the main issue leading here is another case of `alias` not working as people expect:
    alias fn = __traits(getOverloads, t, "fn", true)[0]; // error : alias `fn` cannot alias an expression `t.fn`
    alias tfn = __traits(getOverloads, t, "fn", true)[1]; // error : alias `tfn` cannot alias an expression `t.fn()(float)`

    fnptr = &fn;
    tfnptr = &tfn!();
}

I think this whole block of code should compile; the template instanton issue, and also the "alias not working as expected" issue.

[TurkeyMan]

If anyone can think of a workaround here, I'd be interested to know of one... I can't find any arrangement of syntax which will allow me to capture a function pointer of an instantiated template function.
I need to instantiate a template overload to capture a function pointer; implicit instantiation (as would be used if I were to CALL the overload) does not apply.

[tgehr]

Here is a workaround:

struct Test{
    void fn(int){}
    void fn()(float){}
}

void test(){
    Test t;
    void delegate(int) fnptr = &__traits(getOverloads, t, "fn", true)[0];
    alias tfn = __traits(getOverloads, typeof(t), "fn", true)[1];
    void delegate(float) tfnptr = &__traits(child, t, tfn!());
}

I also think your variants should just work though.

[TurkeyMan]

Wow, that's quite confusing; I wouldn't have imagined to put the instantiation INSIDE the __traits(child) like that...
You appear to be instantiating the method template before it's bound as a method, so apparently it happily instantiates into some un-bound member-function object, which can later be attached to its instance? I guess I can see how that works, but I really had to think about it to convince myself this made sense!

Can you attach any member function to any instance like this? Could I attach the function to an instance of a different type? If you take typeof an unbound member function symbol, it doesn't show anything in the type that knows what type of this it belongs to.

C/C++ has this pointer-to-member syntax, and we sorely lack something like that to express this sort of thing (ie, an unbound member reference). In D; there's no visible/expressible distinction between an unbound member function and a free/(static) function. When you get a function symbol for a method from the T (ie, unbound member), the typeof shows R function(...) as if it's a static function, and it does NOT show the this argument in the first position, and doesn't hint at the type it binds to. There's no way to see that it's an unbound member rather than a simple static function. That's quite confusing when you're parsing through analytical code which is discovering members.
I feel like there's room for a third kind of thing beside function/delegate (ie; member?) for a pointer to an unbound member...

Thank you!