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

          Issue ID: 14346
           Summary: is-expression dependent on instantiation order
           Product: D
           Version: D2
          Hardware: x86_64
                OS: Linux
            Status: NEW
          Severity: normal
          Priority: P1
         Component: DMD
          Assignee: nobody@puremagic.com
          Reporter: schuetzm@gmx.net

This is a really weird bug. Here's how far I could reduce it:

struct Validate() {
    this(string ) {
    }
}

template isConvertibleToInstanceOf(alias From, alias To)
{
    enum isConvertibleToInstanceOf = isConvertibleToInstanceOf!(typeof(From),
To);
}

template isConvertibleToInstanceOf(From, alias To)
{
    enum isConvertibleToInstanceOf =
            is(From : To!Args, Args...);
}


template Validation() {
    void validate() {
        // run validators for members
        foreach(member; __traits(allMembers, typeof(this))) {
            foreach(UDA; __traits(getAttributes, mixin(member))) {
// THE FOLLOWING LINE IS MAGIC
                static if(isConvertibleToInstanceOf!(UDA, Validate)) { }
// ---------------------------
            }
        }

        // run validators for entire object
        foreach(UDA; __traits(getAttributes, typeof(this))) {
// THE RESULT OF THIS IS-EXPR DEPENDS ON THE LINE ABOVE:
            static if(isConvertibleToInstanceOf!(UDA, Validate))
                pragma(msg, "isConvertibleToInstanceOf: ", typeof(UDA));
        }
    }
}


struct EmbeddedType { }
EmbeddedType Embedded;


@Embedded
class Address {
    @Validate!()("invalid country")
    string country;
    mixin Validation;
}


When the first `static if` is there, the `pragma` prints "isConvertibleToInstanceOf: EmbeddedType". But if it is removed or commented out, the `pragma` isn't called; evidently the second `static if` fails.

--