Re: Privacy violation depending on who passes a compile-time argument?

[rcorre via Digitalmars-d-learn]

On Sunday, 14 August 2016 at 15:47:16 UTC, Basile B. wrote:
No it's the opposite, only mixins gets the scope of the 
instantiation's location.

Right, if it were a mixin, it would get the scope of the 
instantiation (the main
module) and `i` would be inacessible.

Since it isn't a mixin, I would expect the scope to be in module 
s, where it
_can_ access `i`.


Try to compile this:

struct S
{
    private int i;
    int j;
    alias getMember(string name) = 
Identity!(__traits(getMember, S, name));
    alias getMember_i = getMember!"i";

    unittest
    {
        pragma(msg, __traits(getProtection, S.getMember!"i")); 
// private
        pragma(msg, __traits(getProtection, S.getMember!"j")); 
// public
    }
}

You'll see that this is even not a matter of module. Actually 
your "getMember" is not a member function, it's an alias to the 
source, i.e the same symbol with the same protection.

Ok, so S.getMember!"i" is really the same as S.i, so I get why 
it's private. But
getMember_i is just an alias to that, so shouldn't it also be 
private?

It makes sense if you accept the following:

struct S {
    private int _i;
    alias i = i;
}

Which I used to accept without thinking about it, but now I'm 
wondering why that
works.