| //https://issues.dlang.org/show_bug.cgi?id=22291 |
| |
| alias AliasSeq(T...) = T; |
| void noParameters() |
| { |
| static assert(typeof(__traits(parameters)).length == 0); |
| } |
| void noArgs() |
| { |
| //Arguments are not valid, this should not compile |
| static assert(!__traits(compiles, __traits(parameters, 456))); |
| } |
| shared static this() |
| { |
| static assert(typeof(__traits(parameters)).length == 0); |
| } |
| int echoPlusOne(int x) |
| { |
| __traits(parameters)[0] += 1; |
| return x; |
| } |
| static assert(echoPlusOne(1) == 2); |
| |
| void nesting(double d, int i) |
| { |
| alias EXP = AliasSeq!(d, i); |
| |
| if (d) |
| { |
| static assert(__traits(isSame, __traits(parameters), EXP)); |
| |
| while (d) |
| { |
| static assert(__traits(isSame, __traits(parameters), EXP)); |
| switch (i) |
| { |
| static assert(__traits(isSame, __traits(parameters), EXP)); |
| case 1: |
| static assert(__traits(isSame, __traits(parameters), EXP)); |
| break; |
| |
| default: |
| static assert(__traits(isSame, __traits(parameters), EXP)); |
| break; |
| } |
| } |
| } |
| } |
| |
| class Tree { |
| int opApply(int delegate(size_t, Tree) dg) { |
| if (dg(0, this)) return 1; |
| return 0; |
| } |
| } |
| void useOpApply(Tree top, int x) |
| { |
| foreach(idx; 0..5) |
| { |
| static assert(is(typeof(__traits(parameters)) == AliasSeq!(Tree, int))); |
| } |
| foreach(idx, elem; top) |
| { |
| static assert(is(typeof(__traits(parameters)) == AliasSeq!(Tree, int))); |
| } |
| |
| foreach(idx, elem; top) |
| { |
| foreach (idx2, elem2; elem) |
| static assert(is(typeof(__traits(parameters)) == AliasSeq!(Tree, int))); |
| } |
| |
| foreach(idx, elem; top) |
| { |
| static void foo(char[] text) |
| { |
| foreach (const char c; text) |
| static assert(is(typeof(__traits(parameters)) == AliasSeq!(char[]))); |
| } |
| } |
| } |
| class Test |
| { |
| static assert(!__traits(compiles, __traits(parameters))); |
| void handle(int x) |
| { |
| static assert(typeof(__traits(parameters)).length == 1); |
| } |
| } |
| |
| int add(int x, int y) |
| { |
| return x + y; |
| } |
| |
| auto forwardToAdd(int x, int y) |
| { |
| return add(__traits(parameters)); |
| } |
| static assert(forwardToAdd(2, 3) == 5); |
| struct TestConstructor |
| { |
| int x; |
| string y; |
| //This parameter will not have a name but it's (tuple) members |
| //will |
| this(typeof(this.tupleof)) |
| { |
| this.tupleof = __traits(parameters); |
| } |
| } |
| bool test(int x, string y) |
| { |
| auto s = TestConstructor(2, "pi"); |
| return s.x == x && s.y == y; |
| } |
| static assert(test(2, "pi")); |
| int testNested(int x) |
| { |
| static assert(typeof(__traits(parameters)).length == 1); |
| int add(int x, int y) |
| { |
| static assert(typeof(__traits(parameters)).length == 2); |
| return x + y; |
| } |
| return add(x + 2, x + 3); |
| } |
| void testPack(Pack...)(Pack x) |
| { |
| static assert(is(typeof(__traits(parameters)) == typeof(AliasSeq!(x)))); |
| } |
| |
| ref int forwardTest(return ref int x) |
| { |
| static assert(__traits(isRef, x) == __traits(isRef, __traits(parameters)[0])); |
| return x; |
| } |
| |
| int testRefness(int x, ref int monkey) |
| { |
| { |
| //monkey = x; |
| __traits(parameters)[1] = __traits(parameters)[0]; |
| } |
| return x; |
| } |
| int refTest() |
| { |
| int x; |
| testRefness(45, x); |
| return x; |
| } |
| auto packLength(Pack...)(Pack x) |
| { |
| return typeof(__traits(parameters)).length; |
| } |
| static assert(packLength(2, 3) == 2); |
| alias lambda = (x) => typeof(__traits(parameters)).stringof; |
| static assert(lambda(1) == "(int)"); |
| static assert(refTest() == 45); |
| |
| T testTemplate(T)(scope T input) |
| { |
| void chimpInASuit(float set) |
| { |
| static assert(is(typeof(__traits(parameters)) == AliasSeq!(float))); |
| } |
| { |
| __traits(parameters) = AliasSeq!(T.max); |
| } |
| __traits(parameters) = AliasSeq!(T.init); |
| return input; |
| } |
| |
| static assert(testTemplate!long(420) == 0); |
| |
| void qualifiers(immutable int a, const bool b) |
| { |
| static assert(is(typeof(__traits(parameters)) == AliasSeq!(immutable int, const bool))); |
| } |
| |
| int makeAggregate(int a, bool b) |
| { |
| struct S |
| { |
| typeof(__traits(parameters)) members; |
| } |
| |
| S s = S(__traits(parameters)); |
| assert(s.members[0] == a); |
| assert(s.members[1] == b); |
| return 1; |
| } |
| |
| static assert(makeAggregate(5, true)); |
| |
| int makeAlias(int a, bool b) |
| { |
| alias Params = __traits(parameters); |
| assert(Params[0] == 3); |
| assert(Params[1] == true); |
| return 1; |
| } |
| |
| static assert(makeAlias(3, true)); |
| |
| |
| mixin template nestedCheckParameters(int unique) |
| { |
| alias NestedNames = __traits(parameters); |
| version (Fixed) |
| alias Types = typeof(Names); |
| } |
| |
| mixin template checkParameters(int unique) |
| { |
| mixin nestedCheckParameters!unique; |
| |
| alias Names = __traits(parameters); |
| alias Types = typeof(Names); |
| } |
| |
| int makeAggregateMixin(immutable int a, const bool b) |
| { |
| mixin checkParameters!0; |
| |
| struct S |
| { |
| mixin checkParameters!1; |
| typeof(Names) members; |
| } |
| |
| S s = S(Names); |
| assert(s.members[0] == a); |
| assert(s.members[1] == b); |
| return 1; |
| } |