如何获得模块的所有成员/功能？

Question

module testmodule;

struct testmodule {}

pragma(msg, __traits(allMembers, testmodule));
pragma(msg, __traits(allMembers, .testmodule));

Prints:

tuple()
tuple()

How do I do it when a declaration in the module has the name of the module?

Answer 1

For the specific case where you know testmodule refers to a struct that is a child of the module testmodule , you can use:

pragma(msg, __traits(allMembers, __traits(parent, testmodule));

If you need to determine whether or not a symbol is actually a module, here's something I threw together quickly that seems to work:

template isModule(alias sym) {
  enum isModule = !__traits(compiles, sym.sizeof);
}

static assert(!isModule!testmodule);
static assert(isModule!(__traits(parent, testmodule)));

I'm basically guessing that anything other than a module will have a sizeof property, but I may be forgetting some other kind of non-module symbol which does not have sizeof .

Answer 2

No built-in mechanism for this disambugation is provided because usually compiler can figure it on its own and such necessity was simply not foreseen.

Here is a simple library utility that generalizes approach proposed by @rcorre (nice idea!):

module getmod;

struct getmod {};

template isModule(alias sym)        
{
    static if (is(typeof(sym) == function))
        enum isModule = false;
    else
    {
        import std.array : startsWith;
        enum isModule = sym.stringof.startsWith("module ");
    }
}

template Module(alias sym)
    if (isModule!sym)
{
    alias Module = sym;
}

template Module(alias sym)
    if (!isModule!sym)
{
    import std.typetuple : TT = TypeTuple;
    alias Module = TT!(__traits(parent, sym))[0];
}

pragma(msg, __traits(allMembers, Module!getmod));
// tuple("object", "getmod", "isModule", "Module", "main")

This is not as good as built-in symbol disamgutation but should be practical enough.