| alias TypeTuple(T...) = T; |
| |
| class A { } |
| class B : A { } |
| class C : B { } |
| |
| /***************************************/ |
| |
| template Foo(int a, int b, int c) |
| { |
| const int Foo = 1; |
| } |
| |
| template Foo(A...) |
| { |
| const int Foo = 2; |
| } |
| |
| void test1() |
| { |
| int y = Foo!(1,2,3); |
| assert(y == 1); |
| |
| y = Foo!(1,2); |
| assert(y == 2); |
| |
| y = Foo!(1,2,3,4); |
| assert(y == 2); |
| } |
| |
| /***************************************/ |
| |
| template Foo2(int a, int b, int c) |
| { |
| const int Foo2 = 1; |
| } |
| |
| template Foo2(int a, int b, int c, A...) |
| { |
| const int Foo2 = 2; |
| } |
| |
| void test2() |
| { |
| int y = Foo2!(1,2,3); |
| assert(y == 1); |
| |
| y = Foo2!(1,2,3,4); |
| assert(y == 2); |
| } |
| |
| /***************************************/ |
| |
| void bar3(int x, int y) |
| { |
| assert(x == 2); |
| assert(y == 3); |
| } |
| |
| template Foo3(T, A...) |
| { |
| int Foo3(T t, A a) |
| { |
| assert(A.length == 2); |
| assert(a.length == 2); |
| bar3(a); |
| assert([a] == [2, 3]); |
| assert([cast(double)a] == [2.0, 3.0]); |
| assert(a[0] == 2); |
| assert(a[1] == 3); |
| assert(a[$ - 2] == 2); |
| assert(a[$ - 1] == 3); |
| static if (1 || a[6]) |
| assert(1); |
| assert([a[]] == [2, 3]); |
| assert([a[0 .. $]] == [2, 3]); |
| assert([a[0 .. $ - 1]] == [2]); |
| return 3; |
| } |
| } |
| |
| void test3() |
| { |
| int y = Foo3(1,2,3); |
| assert(y == 3); |
| } |
| |
| /***************************************/ |
| |
| |
| void foo4(A...)() |
| { |
| int[] ai; |
| int[] aa; |
| |
| aa = null; |
| foreach (a; A) |
| { |
| aa ~= a; |
| } |
| assert(aa == [7,4,9]); |
| |
| aa = null; |
| foreach (int a; A) |
| { |
| aa ~= a; |
| } |
| assert(aa == [7,4,9]); |
| |
| ai = null; |
| aa = null; |
| foreach (int i, a; A) |
| { |
| ai ~= i; |
| aa ~= a; |
| } |
| assert(ai == [0,1,2]); |
| assert(aa == [7,4,9]); |
| |
| ai = null; |
| aa = null; |
| foreach_reverse (uint i, a; A) |
| { |
| ai ~= i; |
| aa ~= a; |
| } |
| assert(ai == [2,1,0]); |
| assert(aa == [9,4,7]); |
| |
| ai = null; |
| aa = null; |
| foreach_reverse (i, a; A) |
| { |
| ai ~= i; |
| aa ~= a; |
| } |
| assert(ai == [2,1,0]); |
| assert(aa == [9,4,7]); |
| |
| ai = null; |
| aa = null; |
| foreach (int i, a; A) |
| { |
| ai ~= i; |
| aa ~= a; |
| if (i == 1) |
| break; |
| continue; |
| } |
| assert(ai == [0,1]); |
| assert(aa == [7,4]); |
| } |
| |
| void test4() |
| { |
| foo4!(7,4,9)(); |
| } |
| |
| /***************************************/ |
| |
| int a12(TypeTuple!(int, int) t) |
| { |
| return t[0] + t[1]; |
| } |
| |
| int b12(TypeTuple!(TypeTuple!(int), TypeTuple!(int)) t) |
| { |
| return t[0] + t[1]; |
| } |
| |
| int c12(TypeTuple!(TypeTuple!(int), TypeTuple!(TypeTuple!(), int), TypeTuple!()) t) |
| { |
| return t[0] + t[1]; |
| } |
| |
| void test12() |
| { |
| assert(a12(1, 2) == 3); |
| assert(b12(1, 2) == 3); |
| assert(c12(1, 2) == 3); |
| } |
| |
| /***************************************/ |
| |
| |
| int plus13(TypeTuple!(int, long, float)[0 .. 2] t) |
| { |
| typeof(t)[0] e; |
| assert(typeid(typeof(e)) == typeid(int)); |
| typeof(t)[1] f; |
| assert(typeid(typeof(f)) == typeid(long)); |
| return t[0] + cast(int)t[1]; |
| } |
| |
| void test13() |
| { |
| assert(plus13(5, 6) == 11); |
| } |
| |
| /***************************************/ |
| |
| int plus14(TypeTuple!(int, long, float)[0 .. $ - 1] t) |
| { |
| typeof(t)[$ - 2] e; |
| assert(typeid(typeof(e)) == typeid(int)); |
| typeof(t)[1] f; |
| assert(typeid(typeof(f)) == typeid(long)); |
| return t[0] + cast(int)t[1]; |
| } |
| |
| void test14() |
| { |
| assert(plus14(5, 6) == 11); |
| } |
| |
| /***************************************/ |
| |
| void returnAndArgs(T, U...) (T delegate(U) dg) |
| { |
| static if (U.length == 0) |
| assert(dg() == 0); |
| else static if (U.length == 1) |
| assert(dg(false) == 1); |
| else |
| assert(dg(false, 63L) == 2); |
| } |
| |
| void test24() |
| { |
| returnAndArgs(delegate int(){ return 0; }); |
| returnAndArgs(delegate int(bool b){ return 1; }); |
| returnAndArgs(delegate int(bool b, long c){ return 2; }); |
| } |
| |
| /***************************************/ |
| |
| void test28() |
| { |
| alias TypeTuple!(int, long, double) TL; |
| |
| foreach (int i, T; TL) |
| { |
| switch (i) |
| { |
| case 0: assert(is(T == int)); break; |
| case 1: assert(is(T == long)); break; |
| case 2: assert(is(T == double)); break; |
| default:assert(0); |
| } |
| } |
| } |
| |
| /***************************************/ |
| |
| template g32(alias B) |
| { |
| int g32 = 2; |
| } |
| |
| int f32(A...)(A a) |
| { |
| return g32!(a); |
| } |
| |
| void test32() |
| { |
| assert(f32(4) == 2); |
| } |
| |
| /***************************************/ |
| |
| struct S34 |
| { |
| int x; |
| long y; |
| double z; |
| } |
| |
| void foo34(int x, long y, double z) |
| { |
| assert(x == 3); |
| assert(y == 8); |
| assert(z == 6.8); |
| } |
| |
| void test34() |
| { |
| S34 s; |
| |
| s.x = 3; |
| s.y = 8; |
| s.z = 6.8; |
| foo34(s.tupleof); |
| } |
| |
| /***************************************/ |
| |
| alias TypeTuple!(int, long, double) TL35; |
| |
| struct S35 |
| { |
| TL35 tl; |
| } |
| |
| void foo35(int x, long y, double z) |
| { |
| assert(x == 3); |
| assert(y == 8); |
| assert(z == 6.8); |
| } |
| |
| void test35() |
| { |
| S35 s; |
| |
| s.tl[0] = 3; |
| s.tl[1] = 8; |
| s.tl[2] = 6.8; |
| foo35(s.tupleof); |
| foo35(s.tl); |
| } |
| |
| /***************************************/ |
| |
| alias TypeTuple!(int, long, double) TL36; |
| |
| class C36 |
| { |
| TL36 tl; |
| } |
| |
| void foo36(int x, long y, double z) |
| { |
| assert(x == 3); |
| assert(y == 8); |
| assert(z == 6.8); |
| } |
| |
| void test36() |
| { |
| C36 s = new C36; |
| |
| s.tl[0] = 3; |
| s.tl[1] = 8; |
| s.tl[2] = 6.8; |
| foo36(s.tupleof); |
| foo36(s.tl); |
| } |
| |
| /***************************************/ |
| |
| |
| alias TypeTuple!(int, long, double) TL37; |
| |
| class C37 |
| { |
| TL37 tl; |
| } |
| |
| void foo37(int x, long y, double z) |
| { |
| assert(x == 3); |
| assert(y == 8); |
| assert(z == 6.8); |
| } |
| |
| void test37() |
| { |
| C37 s = new C37; |
| |
| s.tl[0] = 3; |
| s.tl[1] = 8; |
| s.tl[2] = 6.8; |
| foo37(s.tupleof); |
| |
| TL37 x; |
| assert(x[0] == 0); |
| x[0] = 3; |
| assert(x[0] == 3); |
| assert(x[1] == 0); |
| x[1] = 8; |
| x[2] = 6.8; |
| foo37(x); |
| } |
| |
| /***************************************/ |
| |
| interface I38A { } |
| interface I38B { } |
| |
| alias TypeTuple!(I38A, I38B) IL38; |
| |
| class C38 : IL38 |
| { |
| } |
| |
| void test38() |
| { |
| auto c = new C38; |
| } |
| |
| /***************************************/ |
| |
| void test39() |
| { |
| static const string a = "\x01"; |
| static const char b = a[0]; |
| static const string c = "test"; |
| static assert(c[a[0]] == 'e'); |
| |
| alias TypeTuple!(ulong,uint,ushort,ubyte) tuple; |
| static assert(is(tuple[1] == uint)); |
| static assert(is(tuple[a[0]] == uint)); |
| } |
| |
| /***************************************/ |
| |
| struct Foo45 |
| { |
| static TypeTuple!(int) selements1; |
| TypeTuple!(int) elements1; |
| static TypeTuple!() selements0; |
| TypeTuple!() elements0; |
| } |
| |
| void test45() |
| { |
| Foo45 foo; |
| |
| static assert(Foo45.selements1.length == 1); |
| static assert(Foo45.elements1.length == 1); |
| static assert(Foo45.selements0.length == 0); |
| static assert(Foo45.elements0.length == 0); |
| |
| static assert(foo.selements1.length == 1); |
| static assert(foo.elements1.length == 1); |
| static assert(foo.selements0.length == 0); |
| static assert(foo.elements0.length == 0); |
| } |
| |
| /***************************************/ |
| |
| template Tuple46(E ...) { alias E Tuple46; } |
| |
| alias Tuple46!(float, float, 3) TP46; |
| alias TP46[1..$] TQ46; |
| |
| void test46() |
| { |
| TQ46[0] f = TQ46[1]; |
| assert(is(typeof(f) == float)); |
| assert(f == 3); |
| } |
| |
| /***************************************/ |
| |
| template Foo47(T, Args...) |
| { |
| void bar(Args args, T t) |
| { |
| } |
| } |
| |
| void test47() |
| { |
| alias Foo47!(int) aFoo; |
| } |
| |
| /***************************************/ |
| |
| template Tuple48(E...) |
| { |
| alias E Tuple48; |
| } |
| |
| void VarArg48(T...)(T args) |
| { |
| } |
| |
| void test48() |
| { |
| VarArg48( ); |
| VarArg48( Tuple48!(1,2,3) ); |
| VarArg48( Tuple48!() ); |
| } |
| |
| /***************************************/ |
| |
| alias TypeTuple!(int, long) TX49; |
| |
| void foo49(TX49 t) |
| { |
| TX49 s; |
| s = t; |
| assert(s[0] == 1); |
| assert(s[1] == 2); |
| } |
| |
| void test49() |
| { |
| foo49(1, 2); |
| } |
| |
| /***************************************/ |
| |
| void foo51(U...)(int t, U u) |
| { |
| assert(t == 1); |
| assert(u[0] == 2); |
| assert(u[1] == 3); |
| } |
| |
| void bar51(U...)(U u, int t) |
| { |
| assert(u[0] == 1); |
| assert(u[1] == 2); |
| assert(t == 3); |
| } |
| |
| void abc51(U...)(int s, U u, int t) |
| { |
| assert(s == 1); |
| assert(u[0] == 2); |
| assert(u[1] == 3); |
| assert(t == 4); |
| } |
| |
| void test51() |
| { |
| foo51(1, 2, 3); |
| bar51(1, 2, 3); |
| bar51!(int, int)(1, 2, 3); |
| abc51(1,2,3,4); |
| } |
| |
| /***************************************/ |
| |
| string to55(U, V)(V s) { return "he"; } |
| |
| private S wyda(S, T...)(T args) |
| { |
| S result; |
| foreach (i, arg; args) |
| { |
| result ~= to55!(S)(args[i]); |
| } |
| return result; |
| } |
| |
| string giba(U...)(U args) |
| { |
| return wyda!(string, U)(args); |
| } |
| |
| void test55() |
| { |
| assert(giba(42, ' ', 1.5, ": xyz") == "hehehehe"); |
| } |
| |
| /***************************************/ |
| |
| private template implicitlyConverts(U, V) |
| { |
| enum bool implicitlyConverts = V.sizeof >= U.sizeof |
| && is(typeof({U s; V t = s;}())); |
| } |
| |
| T to56(T, S)(S s) |
| if (!implicitlyConverts!(S, T) /*&& isSomeString!(T) |
| && isSomeString!(S)*/) |
| { |
| return T.init; |
| } |
| |
| void test56() |
| { |
| auto x = to56!(int)("4"); |
| assert(x == 0); |
| assert(!implicitlyConverts!(const(char)[], string)); |
| assert(implicitlyConverts!(string, const(char)[])); |
| } |
| |
| /***************************************/ |
| |
| struct A57(B...) {} |
| |
| void test57() |
| { |
| alias A57!(int, float) X; |
| static if (!is(X Y == A57!(Z), Z...)) |
| { |
| static assert(false); |
| } |
| } |
| |
| /***************************************/ |
| |
| struct A58(B...) {} |
| |
| void test58() |
| { |
| alias A58!(int, float) X; |
| static if (!is(X Y == A58!(Z), Z...)) |
| { |
| static assert(false); |
| } |
| } |
| |
| /***************************************/ |
| |
| struct Tuple59(T...) |
| { |
| T field; |
| } |
| |
| template reduce(fun...) |
| { |
| alias Reduce!(fun).reduce reduce; |
| } |
| |
| template Reduce(fun...) |
| { |
| Tuple59!(double, double) |
| reduce(Range)(Range r) |
| { |
| typeof(Tuple59!(double,double).field)[0] y; |
| typeof(typeof(return).field)[0] x; |
| Tuple59!(double, double) s; |
| return s; |
| } |
| } |
| |
| void test59() |
| { |
| double[] a = [ 3.0, 4, 7, 11, 3, 2, 5 ]; |
| static double sum(double a, double b) {return a + b;} |
| auto r = reduce!((a, b) { return a + b; }, |
| (a, b) { return a + b; })(a); |
| } |
| |
| /***************************************/ |
| |
| template tuple60(T...) |
| { |
| alias T tuple60; |
| } |
| |
| template Foo60(S : void delegate(tuple60!(int))) {} |
| template Foo60(S : void delegate(tuple60!(int, int))) {} |
| |
| alias Foo60!(void delegate(int)) Bar60; |
| |
| void test60() |
| { |
| } |
| |
| /***************************************/ |
| |
| template TypeTuple61(TList...){ |
| alias TList TypeTuple61; |
| } |
| template List61(lst...) { alias lst list; } |
| alias TypeTuple61!(List61!(void)) A61; |
| alias TypeTuple61!(A61[0].list) B61; |
| |
| void test61() |
| { |
| } |
| |
| /***************************************/ |
| |
| template Tuple63(T...){ |
| alias T Tuple63; |
| } |
| // Bugzilla 3336 |
| static assert(!is(int[ Tuple63!(int, int) ])); |
| |
| void test63() |
| { |
| } |
| |
| /***************************************/ |
| |
| template Tuple1411(T ...) { alias T Tuple1411; } |
| |
| void test1411() |
| { |
| int delegate(ref Tuple1411!(int, char[], real)) dg; // (*) |
| int f(ref int a, ref char[] b, ref real c) { return 77; } |
| dg = &f; |
| } |
| |
| /***************************************/ |
| // Bugzilla 4444 |
| |
| void test4444() |
| { |
| alias TypeTuple!(1) index; |
| auto arr = new int[4]; |
| auto x = arr[index]; // error |
| } |
| |
| /***************************************/ |
| // 13864 |
| |
| struct Tuple13864(T...) |
| { |
| T expand; |
| alias expand this; |
| } |
| auto tuple13864(T...)(T args) |
| { |
| return Tuple13864!T(args); |
| } |
| |
| void test13864() |
| { |
| int[] x = [2,3,4]; |
| auto y = x[tuple13864(0).expand]; |
| assert(y == 2); |
| } |
| |
| /***************************************/ |
| // 4884 |
| |
| struct A4884(T...) |
| { |
| void foo(T) {} |
| void bar(bool, T) {} |
| } |
| |
| void test4884() |
| { |
| auto a1 = A4884!(int)(); |
| auto a2 = A4884!(int, long)(); |
| } |
| |
| /***************************************/ |
| // 4920 |
| |
| struct Test4920(parameters_...) |
| { |
| alias parameters_ parameters; |
| } |
| |
| void test4920() |
| { |
| Test4920!(10, 20, 30) test; |
| static assert(typeof(test).parameters[1] == 20); // okay |
| static assert( test .parameters[1] == 20); // (7) |
| } |
| |
| /***************************************/ |
| // 4940 |
| |
| template Tuple4940(T...) |
| { |
| alias T Tuple4940; |
| } |
| |
| struct S4940 |
| { |
| Tuple4940!(int, int) x; |
| this(int) { } |
| } |
| |
| void test4940() |
| { |
| auto w = S4940(0).x; |
| } |
| |
| //---- |
| |
| struct S4940add |
| { |
| string s; |
| long x; |
| } |
| |
| ref S4940add get4940add(ref S4940add s){ return s; } |
| |
| void test4940add() |
| { |
| S4940add s; |
| get4940add(s).tupleof[1] = 20; |
| assert(s.x == 20); |
| } |
| |
| /***************************************/ |
| // 6530 |
| |
| struct S6530 |
| { |
| int a, b, c; |
| } |
| |
| struct HasPostblit6530 |
| { |
| this(this) {} // Bug goes away without this. |
| } |
| |
| auto toRandomAccessTuple6530(T...)(T input, HasPostblit6530 hasPostblit) |
| { |
| return S6530(1, 2, 3); |
| } |
| |
| void doStuff6530(T...)(T args) |
| { |
| HasPostblit6530 hasPostblit; |
| |
| // Bug goes away without the .tupleof. |
| auto foo = toRandomAccessTuple6530(args, hasPostblit).tupleof; |
| } |
| |
| void test6530() |
| { |
| doStuff6530(1, 2, 3); |
| } |
| |
| /***************************************/ |
| |
| import core.stdc.stdarg; |
| |
| extern(C) |
| void func9495(int a, string format, ...) |
| { |
| va_list ap; |
| va_start(ap, format); |
| auto a1 = va_arg!int(ap); |
| auto a2 = va_arg!int(ap); |
| auto a3 = va_arg!int(ap); |
| assert(a1 == 0x11111111); |
| assert(a2 == 0x22222222); |
| assert(a3 == 0x33333333); |
| va_end(ap); |
| } |
| |
| void test9495() |
| { |
| func9495(0, "", 0x11111111, 0x22222222, 0x33333333); |
| } |
| |
| /***************************************/ |
| |
| void copya(int a, string format, ...) |
| { |
| va_list ap; |
| va_start(ap, format); |
| |
| va_list ap2; |
| va_copy(ap2, ap); |
| |
| auto a1 = va_arg!int(ap); |
| auto a2 = va_arg!int(ap); |
| auto a3 = va_arg!int(ap); |
| |
| assert(a1 == 0x11111111); |
| assert(a2 == 0x22222222); |
| assert(a3 == 0x33333333); |
| |
| auto b1 = va_arg!int(ap2); |
| auto b2 = va_arg!int(ap2); |
| auto b3 = va_arg!int(ap2); |
| |
| assert(b1 == 0x11111111); |
| assert(b2 == 0x22222222); |
| assert(b3 == 0x33333333); |
| |
| va_end(ap); |
| va_end(ap2); |
| } |
| |
| void testCopy() |
| { |
| copya(0, "", 0x11111111, 0x22222222, 0x33333333); |
| } |
| |
| /***************************************/ |
| // 6700 |
| |
| template bug6700(TList ...) { |
| const int bug6700 = 2; |
| } |
| TypeTuple!(int, long) TT6700; |
| |
| static assert(bug6700!( (TT6700[1..$]) )==2); |
| |
| /***************************************/ |
| // 6966 |
| |
| template X6966(T...) |
| { |
| alias const(T[0]) X6966; |
| } |
| static assert(is(X6966!(int) == const(int))); |
| static assert(is(X6966!(int, 0) == const(int))); |
| |
| /***************************************/ |
| // 7233 |
| |
| struct Foo7233 { int x, y; } |
| Foo7233[] front7233(Foo7233[][] a) |
| { |
| return a[0]; |
| } |
| |
| class Bar7233 { int x, y; } |
| Bar7233[] front7233(Bar7233[][] a) |
| { |
| return a[0]; |
| } |
| |
| void test7233() |
| { |
| Foo7233[][] b1 = [[Foo7233()]]; |
| auto xy1 = b1.front7233[0].tupleof; |
| |
| Bar7233[][] b2 = [[new Bar7233()]]; |
| auto xy2 = b2.front7233[0].tupleof; |
| } |
| |
| /***************************************/ |
| // 7263 |
| |
| template TypeTuple7263(T...){ alias T TypeTuple7263; } |
| |
| struct tuple7263 |
| { |
| TypeTuple7263!(int, int) field; |
| alias field this; |
| } |
| |
| auto front7263(T)(ref T arr){ return arr[0]; } |
| |
| void test7263() |
| { |
| auto bars = [tuple7263(0, 0), tuple7263(1, 1)]; |
| auto spam1 = bars.front7263[1]; |
| auto spam2 = bars.front7263[1..2]; |
| } |
| |
| /***************************************/ |
| // 8244 |
| |
| TypeTuple!(int,int)[] x8244; |
| static assert(is(typeof(x8244) == TypeTuple!(int, int))); |
| |
| /***************************************/ |
| // 9017 |
| |
| template X9017(Args...) |
| { |
| static if(__traits(compiles, { enum e = Args; })) |
| enum e = Args; |
| } |
| alias X9017!0 x9017; |
| static assert(x9017.e[0] == 0); |
| |
| void test9017() |
| { |
| enum tup1 = TypeTuple!(11, 22); |
| enum tup2 = TypeTuple!("one", "two"); |
| static assert(tup1 == TypeTuple!(11, 22)); |
| static assert(tup2 == TypeTuple!("one", "two")); |
| static assert(tup1[0] == 11 && tup1[1] == 22); |
| static assert(tup2[0] == "one" && tup2[1] == "two"); |
| |
| shared const tup3 = TypeTuple!(10, 3.14); |
| immutable tup4 = TypeTuple!("a", [1,2]); |
| static assert(is(typeof(tup3[0]) == shared const int)); |
| static assert(is(typeof(tup3[1]) == shared const double)); |
| static assert(is(typeof(tup4[0]) == immutable string)); |
| static assert(is(typeof(tup4[1]) == immutable int[])); |
| } |
| |
| /***************************************/ |
| // 10279 |
| |
| void foo10279(int[][] strs...) @trusted { } |
| void bar10279() @safe { foo10279(); } |
| |
| /***************************************/ |
| // 13508 |
| |
| struct S13508 |
| { |
| this(T)(T[] t...) {} |
| } |
| |
| template make13508(T) |
| { |
| T make13508(Args...)(Args args) |
| { |
| return T(args); |
| } |
| } |
| |
| void test13508() @safe @nogc |
| { |
| S13508 s = make13508!S13508(5); |
| } |
| |
| /***************************************/ |
| // 14395 |
| |
| int v2u14395(uint[1] ar...) |
| { |
| return ar[0]; |
| } |
| |
| void print14395(int size = v2u14395(7)) |
| { |
| assert(size == 7); |
| } |
| |
| void test14395() |
| { |
| print14395(); |
| } |
| |
| /***************************************/ |
| // 10414 |
| |
| void foo10414(void delegate()[] ...) { } |
| |
| void bar10414() { } |
| |
| void test10414() |
| { |
| foo10414 |
| ( |
| { bar10414(); }, |
| { bar10414(); }, |
| ); |
| } |
| |
| /***************************************/ |
| |
| import core.stdc.stdarg; |
| |
| struct S14179 |
| { |
| const(char)* filename; |
| uint linnum; |
| uint charnum; |
| } |
| |
| extern(C++) const(char)* func14179(S14179 x, const(char)* string, ...) |
| { |
| return string; |
| } |
| |
| void test14179() |
| { |
| const(char)* s = "hello"; |
| assert(func14179(S14179(), s) == s); |
| } |
| |
| /***************************************/ |
| // 10722 |
| |
| struct S10722 |
| { |
| int x; |
| } |
| |
| template GetSomething10722(S...) |
| { |
| alias GetSomething = int; |
| } |
| |
| void test10722() |
| { |
| alias X10722 = GetSomething10722!(S10722.tupleof[0]); |
| } |
| |
| /***************************************/ |
| |
| void testx15417(ulong c1, ...) |
| { |
| check(c1, _argptr, _arguments); |
| } |
| |
| class C15417 |
| { |
| private void method () |
| { |
| void test1 (ulong c1, ...) |
| { |
| check(c1, _argptr, _arguments); |
| } |
| |
| void test2 (ulong c1, ...) |
| { |
| va_list ap; |
| va_start(ap, c1); |
| |
| check(c1, ap, _arguments); |
| } |
| |
| testx15417(4242UL, char.init); |
| test1(4242UL, char.init); |
| test2(4242UL, char.init); |
| } |
| } |
| |
| void check (ulong c1, va_list arglist, TypeInfo[] ti) |
| { |
| assert(ti.length == 1); |
| assert(ti[0].toString() == "char"); |
| assert(char.init == va_arg!(char)(arglist)); |
| } |
| |
| void test15417() |
| { |
| auto c = new C15417; |
| c.method; |
| } |
| |
| |
| /***************************************/ |
| |
| int main() |
| { |
| test1(); |
| test2(); |
| test3(); |
| test4(); |
| test12(); |
| test13(); |
| test14(); |
| test24(); |
| test28(); |
| test32(); |
| test34(); |
| test35(); |
| test36(); |
| test37(); |
| test38(); |
| test39(); |
| test45(); |
| test46(); |
| test47(); |
| test48(); |
| test49(); |
| test51(); |
| test55(); |
| test56(); |
| test57(); |
| test58(); |
| test59(); |
| test60(); |
| test61(); |
| test63(); |
| test1411(); |
| test4444(); |
| test13864(); |
| test4884(); |
| test4920(); |
| test4940(); |
| test4940add(); |
| test6530(); |
| test7233(); |
| test7263(); |
| test9017(); |
| test14395(); |
| test10414(); |
| test9495(); |
| testCopy(); |
| test14179(); |
| test15417(); |
| |
| return 0; |
| } |