Hi all,

I'm getting unexpected results while trying to process symbols from a module, some of which are enums.

Depending on whether or not I comment out the first static foreach loop below, fullyQualifiedName gives me different results in the second loop.

In either case, I'm surprised I can't grab the UDAs in the second static foreach loop.  Any ideas what's going on?

Test case:
---a.d---
module a;

@Object
enum x = "hello";

@Object
enum y = "goodbye";

@Object
struct z{}


---main.d---

template symbols(alias Mod){
    import std.meta;
    alias toSymbol(alias T) = __traits(getMember, Mod, T);
    alias symbols = staticMap!(toSymbol, __traits(allMembers, Mod));
}


void main(){
    import std.traits;
    import std.meta;
    import a;
    //commenting this out changes the results below
    static foreach(sym; symbols!a){
        pragma(msg, fullyQualifiedName!sym);
        pragma(msg, __traits(getAttributes, sym));
    }

    pragma(msg, "\nget with UDAs\n");
    pragma(msg, getSymbolsByUDA!(a, Object));
    alias udaSyms = getSymbolsByUDA!(a, Object);
    pragma(msg, staticMap!(fullyQualifiedName, udaSyms));
    static foreach(us; udaSyms){
        pragma(msg, fullyQualifiedName!us);
        pragma(msg, __traits(getAttributes, us));
    }
}

---

annotated output of dmd main.d:

with the first loop commented out:

get with UDAs

tuple("hello", "goodbye", (z))
tuple("a.x", "a.y", "a.z")
a.x
tuple()  //why is the UDA gone?
a.y
tuple()
a.z
tuple((Object))


and with the first loop:

object
tuple()
main.main.sym  //it's not a.x anymore, it's the name of the local var for static foreach?
tuple()
main.main.sym
tuple()
a.z
tuple((Object))

get with UDAs

tuple("hello", "goodbye", (z))
tuple("main.main.sym", "main.main.sym", "a.z") //and the results are changed here too?
main.main.sym
tuple()
main.main.sym
tuple()
a.z
tuple((Object))

On Friday, 14 February 2020 at 22:24:14 UTC, Ben Jones wrote:
> Hi all,
>
> I'm getting unexpected results while trying to process symbols from a module, some of which are enums.
>
> Depending on whether or not I comment out the first static foreach loop below, fullyQualifiedName gives me different results in the second loop.
>
> In either case, I'm surprised I can't grab the UDAs in the second static foreach loop.  Any ideas what's going on?
>
> Test case:
> ---a.d---
> module a;
>
> @Object
> enum x = "hello";
>
> @Object
> enum y = "goodbye";
>
> @Object
> struct z{}
>
>
> ---main.d---
>
> template symbols(alias Mod){
>     import std.meta;
>     alias toSymbol(alias T) = __traits(getMember, Mod, T);
>     alias symbols = staticMap!(toSymbol, __traits(allMembers, Mod));
> }
>
>
> void main(){
>     import std.traits;
>     import std.meta;
>     import a;
>     //commenting this out changes the results below
>     static foreach(sym; symbols!a){
>         pragma(msg, fullyQualifiedName!sym);
>         pragma(msg, __traits(getAttributes, sym));
>     }
>
>     pragma(msg, "\nget with UDAs\n");
>     pragma(msg, getSymbolsByUDA!(a, Object));
>     alias udaSyms = getSymbolsByUDA!(a, Object);
>     pragma(msg, staticMap!(fullyQualifiedName, udaSyms));
>     static foreach(us; udaSyms){
>         pragma(msg, fullyQualifiedName!us);
>         pragma(msg, __traits(getAttributes, us));
>     }
> }
>
> ---
>
> annotated output of dmd main.d:
>
> with the first loop commented out:
>
> get with UDAs
>
> tuple("hello", "goodbye", (z))
> tuple("a.x", "a.y", "a.z")
> a.x
> tuple()  //why is the UDA gone?
> a.y
> tuple()
> a.z
> tuple((Object))
>
>
> and with the first loop:
>
> object
> tuple()
> main.main.sym  //it's not a.x anymore, it's the name of the local var for static foreach?
> tuple()
> main.main.sym
> tuple()
> a.z
> tuple((Object))
>
> get with UDAs
>
> tuple("hello", "goodbye", (z))
> tuple("main.main.sym", "main.main.sym", "a.z") //and the results are changed here too?
> main.main.sym
> tuple()
> main.main.sym
> tuple()
> a.z
> tuple((Object))

From language spec [1]: "the name of the static foreach variable is bound to the i-th entry of the sequence, either as an enum variable declaration (for constants) or an alias declaration (for symbols).

Enums are treated differently, so your 'sym' is not an alias to the original enum but an enum itself with the same value. Because of that, fullyQualifiedName or any template with alias argument will just get the sym temporary not the enum from the symbols tuple.


This code should work:

static foreach(i, _; symbols!a){
         pragma(msg, fullyQualifiedName!(symbols!a[i]));
         // or manually aliased, but you need to use regular foreach or {{ }} to avoid redefinitions.
         alias sym = symbols!a[i];
         pragma(msg, fullyQualifiedName!sym);
      }


[1] https://dlang.org/spec/version.html#staticforeach

On Friday, 14 February 2020 at 22:24:14 UTC, Ben Jones wrote:
> Hi all,
>
> I'm getting unexpected results while trying to process symbols from a module, some of which are enums.
>
> Depending on whether or not I comment out the first static foreach loop below, fullyQualifiedName gives me different results in the second loop.

Looking more in detail it seems there is another peculiarity happening here, it could be that a template instance get reused (issue 14501). Not sure if it's really a bug or by design.


https://issues.dlang.org/show_bug.cgi?id=14501