| /* |
| RUN_OUTPUT: |
| --- |
| Foo3.func() |
| Code3.func() |
| Foo4.func() |
| Foo5.func() |
| b.x = 5 |
| x = 5 |
| duff_for(1, 11) |
| fid = 1, 2 |
| foo12 |
| foo12 |
| foo13 j = 1 |
| foo13 j = 1 |
| x14 = 6 |
| x15 = 6 |
| bar15() = 5 |
| x16 = 6 |
| bar() = 5 |
| x17 = 5 |
| b.x17 = 5 |
| x17 = 3 |
| x17 = 5 |
| x17 = 4 |
| x17 = 3 |
| x17 = 5 |
| in C20.f() |
| B22.foo() |
| 5 |
| 5 |
| a = 0 |
| int |
| int |
| int |
| int |
| foo 1 |
| foo 2 |
| 0 0 |
| two |
| one |
| one |
| Class39 dtor |
| Mixed-in dtor |
| Mixed-in dtor |
| Base39 dtor |
| Success |
| --- |
| */ |
| |
| module mixin1; |
| |
| import core.stdc.stdio; |
| |
| alias TypeTuple(T...) = T; |
| |
| /*******************************************/ |
| |
| mixin template Foo(T) |
| { |
| T x; |
| } |
| |
| mixin Foo!(uint); |
| |
| struct Bar |
| { |
| template Abc(T) |
| { |
| T y; |
| } |
| |
| template Def(T) |
| { |
| T z; |
| } |
| } |
| |
| mixin Bar.Abc!(int); |
| |
| Bar b; |
| mixin typeof(b).Def!(int); |
| |
| void test1() |
| { |
| x = 3; |
| assert(x == 3); |
| y = 4; |
| assert(y == 4); |
| z = 5; |
| assert(z == 5); |
| } |
| |
| /*******************************************/ |
| |
| template Foo2(T) |
| { |
| T x2 = T.sizeof; |
| } |
| |
| mixin Foo2!(uint) B2; |
| mixin Foo2!(long) C2; |
| mixin Foo2!(int); |
| |
| void test2() |
| { |
| B2.x2 = 3; |
| assert(B2.x2 == 3); |
| assert(C2.x2 == long.sizeof); |
| // assert(x2 == int.sizeof); |
| } |
| |
| /*******************************************/ |
| |
| template Foo3(T) |
| { |
| int func() { printf("Foo3.func()\n"); return 1; } |
| } |
| |
| class Bar3 |
| { |
| mixin Foo3!(int); |
| } |
| |
| class Code3 : Bar3 |
| { |
| override int func() { printf("Code3.func()\n"); return 2; } |
| } |
| |
| void test3() |
| { |
| int i; |
| |
| Bar3 b = new Bar3(); |
| i = b.func(); |
| assert(i == 1); |
| |
| b = new Code3(); |
| i = b.func(); |
| assert(i == 2); |
| } |
| |
| /*******************************************/ |
| |
| template Foo4(T) |
| { |
| int func() { printf("Foo4.func()\n"); return 1; } |
| } |
| |
| struct Bar4 |
| { |
| mixin Foo4!(int); |
| } |
| |
| void test4() |
| { |
| int i; |
| |
| Bar4 b; |
| i = b.func(); |
| assert(i == 1); |
| } |
| |
| /*******************************************/ |
| |
| template Foo5() |
| { |
| int func() { printf("Foo5.func()\n"); return 1; } |
| } |
| |
| struct Bar5 |
| { |
| mixin Foo5; |
| } |
| |
| void test5() |
| { |
| int i; |
| |
| Bar5 b; |
| i = b.func(); |
| assert(i == 1); |
| } |
| |
| /*******************************************/ |
| |
| template Foo6() |
| { |
| int x = 5; |
| } |
| |
| struct Bar6 |
| { |
| mixin Foo6; |
| } |
| |
| void test6() |
| { |
| int i; |
| |
| Bar6 b; |
| i = b.x; |
| assert(i == 5); |
| assert(b.sizeof == int.sizeof); |
| } |
| |
| /*******************************************/ |
| |
| template Foo7() |
| { |
| int x = 5; |
| } |
| |
| class Bar7 |
| { |
| int y = 6; |
| mixin Foo7; |
| } |
| |
| void test7() |
| { |
| int i; |
| |
| Bar7 b = new Bar7(); |
| i = b.x; |
| printf("b.x = %d\n", b.x); |
| assert(i == 5); |
| } |
| |
| /*******************************************/ |
| |
| template Foo8() |
| { |
| int x = 5; |
| int bar() { return 7; } |
| } |
| |
| void test8() |
| { |
| mixin Foo8; |
| printf("x = %d\n", x); |
| assert(x == 5); |
| assert(bar() == 7); |
| } |
| |
| /*******************************************/ |
| |
| template Foo9() |
| { |
| int abc() { return y; } |
| } |
| |
| void test9() |
| { |
| int y = 8; |
| mixin Foo9; |
| assert(abc() == 8); |
| } |
| |
| /*******************************************/ |
| |
| template Foo10(alias b) |
| { |
| typeof(b) abc() { return b; } |
| } |
| |
| void test10() |
| { |
| int y = 8; |
| mixin Foo10!(y); |
| assert(abc() == 8); |
| } |
| |
| |
| /*******************************************/ |
| |
| template Foo11(alias b) |
| { |
| int abc() { return b; } |
| } |
| |
| void test11() |
| { |
| int y = 8; |
| mixin Foo11!(y) B; |
| assert(B.abc() == 8); |
| } |
| |
| /*******************************************/ |
| |
| template duff_for(alias id1, alias id2, alias s) |
| { |
| |
| void duff_for() |
| { |
| printf("duff_for(%d, %d)\n", id1, id2); |
| typeof(id1) id = id1; |
| printf("fid = %d, %d\n", id, (id2 - id) % 8); |
| switch ((id2 - id) % 8) |
| { |
| case 0: |
| while (id != id2) |
| { |
| printf("wid = %d\n", id); |
| s(); ++id; |
| goto case; |
| case 7: s(); ++id; goto case; |
| case 6: s(); ++id; goto case; |
| case 5: s(); ++id; goto case; |
| case 4: s(); ++id; goto case; |
| case 3: s(); ++id; goto case; |
| case 2: s(); ++id; goto case; |
| case 1: s(); ++id; |
| break; |
| default: assert(0); |
| } |
| } |
| } |
| } |
| |
| void foo12() { printf("foo12\n"); } |
| |
| void test12() |
| { |
| int i = 1; |
| int j = 11; |
| |
| mixin duff_for!(i, j, delegate void() { foo12(); }); |
| duff_for(); |
| } |
| |
| /*******************************************/ |
| |
| template duff(alias id1, alias id2, alias s) |
| { |
| |
| void duff() |
| { |
| s(); |
| s(); |
| } |
| } |
| |
| void foo13(int j) |
| { |
| printf("foo13 j = %d\n", j); |
| assert(j == 1); |
| } |
| |
| void test13() |
| { |
| int i = 1; |
| int j = 11; |
| |
| mixin duff!(i, j, delegate { foo13(i); }); |
| duff(); |
| } |
| |
| /*******************************************/ |
| |
| template Foo14() |
| { |
| int x14 = 5; |
| } |
| |
| void test14() |
| { |
| int x14 = 6; |
| mixin Foo14; |
| printf("x14 = %d\n", x14); |
| assert(x14 == 6); |
| } |
| |
| /*******************************************/ |
| |
| template Foo15() |
| { |
| int x15 = 5; |
| |
| int bar15() { return x15; } |
| } |
| |
| int x15 = 6; |
| mixin Foo15; |
| |
| void test15() |
| { |
| |
| printf("x15 = %d\n", x15); |
| printf("bar15() = %d\n", bar15()); |
| assert(x15 == 6); |
| assert(bar15() == 5); |
| } |
| |
| /*******************************************/ |
| |
| template Foo16() |
| { |
| int x16 = 5; |
| |
| int bar() { return x16; } |
| } |
| |
| mixin Foo16 A16; |
| int x16 = 6; |
| mixin Foo16 B16; |
| |
| void test16() |
| { |
| |
| printf("x16 = %d\n", x16); |
| printf("bar() = %d\n", A16.bar()); |
| assert(x16 == 6); |
| assert(A16.x16 == 5); |
| assert(B16.x16 == 5); |
| assert(A16.bar() == 5); |
| assert(B16.bar() == 5); |
| } |
| |
| /*******************************************/ |
| |
| template Foo17() |
| { |
| int x17 = 5; |
| } |
| |
| mixin Foo17; |
| |
| struct Bar17 |
| { |
| mixin Foo17; |
| } |
| |
| void test17() |
| { |
| printf("x17 = %d\n", x17); // prints 5 |
| assert(x17 == 5); |
| { Bar17 b; |
| int x17 = 3; |
| |
| printf("b.x17 = %d\n", b.x17); // prints 5 |
| assert(b.x17 == 5); |
| printf("x17 = %d\n", x17); // prints 3 |
| assert(x17 == 3); |
| { |
| mixin Foo17; |
| printf("x17 = %d\n", x17); // prints 5 |
| assert(x17 == 5); |
| x17 = 4; |
| printf("x17 = %d\n", x17); // prints 4 |
| assert(x17 == 4); |
| } |
| printf("x17 = %d\n", x17); // prints 3 |
| assert(x17 == 3); |
| } |
| printf("x17 = %d\n", x17); // prints 5 |
| assert(x17 == 5); |
| } |
| |
| /*******************************************/ |
| |
| template Foo18() { int z = 3; } |
| |
| struct Bar18(alias Tmpl) |
| { |
| mixin Tmpl; |
| } |
| |
| Bar18!(Foo18) b18; |
| |
| void test18() |
| { |
| assert(b18.z == 3); |
| } |
| |
| /*******************************************/ |
| |
| template Mix1(T) |
| { |
| int foo19(T a) { return 2*a; } |
| } |
| |
| template Mix2(T) |
| { |
| mixin Mix1!(T); |
| |
| int bar19(T a) { return foo19(a); } |
| } |
| |
| mixin Mix2!(int); |
| |
| void test19() |
| { |
| int i; |
| |
| i = bar19(7); |
| assert(i == 14); |
| } |
| |
| /*******************************************/ |
| |
| interface A20 { int f(); } |
| |
| template Foo20() |
| { |
| int f() |
| { |
| printf("in C20.f()\n"); |
| return 6; |
| } |
| } |
| |
| class C20 : A20 |
| { |
| mixin Foo20; |
| // void f() { printf("in C20.f()\n"); } |
| } |
| |
| void test20() |
| { |
| C20 c = new C20(); |
| int i = c.f(); |
| assert(i == 6); |
| } |
| |
| /*******************************************/ |
| |
| template Mix21() { this(int x) { printf("mix1\n"); }} |
| |
| class Bar21 |
| { |
| int myx; |
| mixin Mix21; // wouldn't compile |
| |
| this() { myx = 15; } |
| |
| // mixin Mix21; // placing it here compiles |
| } |
| |
| void test21() |
| { |
| Bar21 bar = new Bar21(); |
| } |
| |
| /*******************************************/ |
| |
| template A22(T) |
| { |
| this() |
| { int i; |
| i = super.foo(); |
| assert(i == 67); |
| } |
| } |
| |
| |
| class B22 |
| { |
| int foo() { printf("B22.foo()\n"); return 67; } |
| } |
| |
| class C22 : B22 |
| { |
| mixin A22!(C22); |
| } |
| |
| void test22() |
| { |
| C22 c = new C22; |
| } |
| |
| |
| /*******************************************/ |
| |
| template Foo23() |
| { |
| const int x = 5; |
| } |
| |
| class C23 |
| { |
| mixin Foo23 F; |
| } |
| |
| struct D23 |
| { |
| mixin Foo23 F; |
| } |
| |
| void test23() |
| { |
| C23 c = new C23; |
| |
| printf("%d\n",c.F.x); |
| assert(c.F.x == 5); |
| |
| D23 d; |
| |
| printf("%d\n",d.F.x); |
| assert(d.F.x == 5); |
| } |
| |
| /*******************************************/ |
| |
| template T24() |
| { |
| void foo24() { return cast(void)0; } |
| // alias foo24 foo24; |
| } |
| |
| mixin T24; |
| |
| void test24() |
| { |
| foo24(); |
| } |
| |
| |
| /*******************************************/ |
| |
| template ctor25() |
| { |
| this() { this(null); } |
| this( Object o ) {} |
| } |
| |
| class Foo25 |
| { |
| mixin ctor25; |
| } |
| |
| void test25() |
| { |
| Foo25 foo = new Foo25(); |
| } |
| |
| |
| /*******************************************/ |
| |
| template Get26(T) |
| { |
| Reader get (ref T x) |
| { |
| return this; |
| } |
| } |
| |
| class Reader |
| { |
| mixin Get26!(byte) bar; |
| alias bar.get get; |
| mixin Get26!(int) beq; |
| alias beq.get get; |
| } |
| |
| void test26() |
| { |
| Reader r = new Reader; |
| Reader s; |
| byte q; |
| s = r.get (q); |
| assert(s == r); |
| } |
| |
| /*******************************************/ |
| |
| template Template(int L) |
| { |
| int i = L; |
| int foo(int b = Template!(9).i) { |
| return b; |
| } |
| } |
| |
| void test27() |
| { |
| int i = 10; |
| int foo(int b = Template!(9).i) { |
| return b; |
| } |
| assert(foo()==9); |
| } |
| |
| /*******************************************/ |
| |
| template Blah28(int a, alias B) |
| { |
| mixin Blah28!(a-1, B); |
| //mixin Blah28!(0, B); |
| } |
| |
| template Blah28(int a:0, alias B) |
| { |
| } |
| |
| void test28() |
| { |
| int a; |
| mixin Blah28!(5,a); |
| printf("a = %d\n", a); |
| } |
| |
| /*******************************************/ |
| |
| template T29() |
| { |
| int x; |
| } |
| |
| struct S29 |
| { |
| mixin T29; |
| int y; |
| } |
| |
| const S29 s29 = { x:2, y:3 }; |
| |
| void test29() |
| { |
| assert(s29.x == 2); |
| assert(s29.y == 3); |
| } |
| |
| /*******************************************/ |
| |
| class A30 |
| { |
| template ctor(Type) |
| { |
| this(Type[] arr) |
| { |
| foreach(Type v; arr) |
| { |
| const str = typeid(typeof(v)).toString(); |
| printf("%.*s\n", cast(int)str.length, str.ptr); |
| } |
| } |
| } |
| |
| mixin ctor!(int); |
| } |
| |
| void test30() |
| { |
| static int[] ints = [0,1,2,3]; |
| A30 a = new A30(ints); |
| } |
| |
| /*******************************************/ |
| |
| template Share(T) { |
| const bool opEquals(ref const T x) { return true; } |
| } |
| |
| struct List31(T) { |
| |
| //int opEquals(List31 x) { return 0; } |
| mixin Share!(List31); |
| } |
| |
| void test31() |
| { |
| List31!(int) x; |
| List31!(int) y; |
| int i = x == y; |
| assert(i == 1); |
| } |
| |
| /*******************************************/ |
| |
| template Blah(int a, alias B) |
| { |
| mixin Blah!(a-1, B); |
| } |
| |
| template Blah(int a:0, alias B) |
| { |
| int foo() |
| { return B + 1; |
| } |
| } |
| |
| void test32() |
| { |
| int a = 3; |
| mixin Blah!(5,a); |
| |
| assert(foo() == 4); |
| } |
| |
| /*******************************************/ |
| |
| template T33( int i ) |
| { |
| int foo() |
| { |
| printf("foo %d\n", i ); |
| return i; |
| } |
| } |
| |
| |
| class C33 |
| { |
| mixin T33!( 1 ) t1; |
| mixin T33!( 2 ) t2; |
| } |
| |
| void test33() |
| { |
| int i; |
| C33 c1 = new C33; |
| i = c1.t1.foo(); |
| assert(i == 1); |
| i = c1.t2.foo(); |
| assert(i == 2); |
| } |
| |
| |
| /*******************************************/ |
| |
| template mix34() |
| { |
| int i; |
| void print() |
| { |
| printf( "%d %d\n", i, j ); |
| assert(i == 0); |
| assert(j == 0); |
| } |
| } |
| |
| void test34() |
| { |
| int j; |
| mixin mix34!(); |
| |
| print(); |
| //printf( "%i\n", i ); |
| } |
| |
| /*******************************************/ |
| |
| mixin T35!(int) m35; |
| |
| template T35(t) |
| { |
| t a; |
| } |
| |
| void test35() |
| { |
| m35.a = 3; |
| } |
| |
| /*******************************************/ |
| |
| struct Foo36 |
| { |
| int a; |
| mixin T!(int) m; |
| template T(t) |
| { |
| t b; |
| } |
| int c; |
| } |
| |
| void test36() |
| { |
| Foo36 f; |
| assert(f.sizeof == 12); |
| |
| f.a = 1; |
| f.m.b = 2; |
| f.c = 3; |
| |
| assert(f.a == 1); |
| assert(f.m.b == 2); |
| assert(f.c == 3); |
| } |
| |
| /*******************************************/ |
| |
| template Foo37() |
| { |
| template func() { |
| int func() { |
| return 6; |
| } |
| } |
| } |
| |
| class Baz37 |
| { |
| mixin Foo37 bar; |
| } |
| |
| void test37() |
| { |
| Baz37 b = new Baz37; |
| auto i = b.bar.func!()(); |
| assert(i == 6); |
| i = (new Baz37).bar.func!()(); |
| assert(i == 6); |
| } |
| |
| /*******************************************/ |
| |
| template Foo38() |
| { |
| int a = 4; |
| |
| ~this() |
| { |
| printf("one\n"); |
| assert(a == 4); |
| assert(b == 5); |
| c++; |
| } |
| } |
| |
| class Outer38 |
| { int b = 5; |
| |
| static int c; |
| |
| mixin Foo38!() bar; |
| mixin Foo38!() abc; |
| |
| ~this() |
| { |
| printf("two\n"); |
| assert(b == 5); |
| assert(c == 0); |
| c++; |
| } |
| } |
| |
| void test38() |
| { |
| Outer38 o = new Outer38(); |
| destroy(o); |
| assert(Outer38.c == 3); |
| } |
| |
| /*******************************************/ |
| |
| template TDtor() |
| { |
| ~this() |
| { |
| printf("Mixed-in dtor\n"); |
| } |
| } |
| |
| class Base39 |
| { |
| ~this() |
| { |
| printf("Base39 dtor\n"); |
| } |
| } |
| |
| class Class39 : Base39 |
| { |
| mixin TDtor A; |
| mixin TDtor B; |
| |
| ~this() |
| { |
| printf("Class39 dtor\n"); |
| } |
| } |
| |
| void test39() |
| { |
| scope test = new Class39; |
| } |
| |
| |
| /*******************************************/ |
| |
| template Mix40() |
| { |
| int i; |
| } |
| |
| struct Z40 |
| { |
| union { mixin Mix40; } |
| } |
| |
| void test40() |
| { |
| Z40 z; |
| z.i = 3; |
| } |
| |
| /*******************************************/ |
| |
| |
| class X41(P...) |
| { |
| alias P[0] Q; |
| mixin Q!(); |
| } |
| |
| template MYP() |
| { |
| void foo() { } |
| } |
| |
| void test41() |
| { |
| X41!(MYP) x; |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2245 |
| |
| template TCALL2245a(ARGS...) |
| { |
| int makecall(ARGS args) |
| { |
| return args.length; |
| } |
| } |
| |
| template TCALL2245b(int n) |
| { |
| int makecall2(ARGS...)(ARGS args) if (ARGS.length == n) |
| { |
| return args.length; |
| } |
| } |
| |
| class C2245 |
| { |
| mixin TCALL2245a!(); |
| mixin TCALL2245a!(int); |
| mixin TCALL2245a!(int,int); |
| |
| mixin TCALL2245b!(0); |
| mixin TCALL2245b!(1); |
| mixin TCALL2245b!(2); |
| } |
| |
| struct S2245 |
| { |
| mixin TCALL2245a!(); |
| mixin TCALL2245a!(int); |
| mixin TCALL2245a!(int,int); |
| |
| mixin TCALL2245b!(0); |
| mixin TCALL2245b!(1); |
| mixin TCALL2245b!(2); |
| } |
| |
| void test2245() |
| { |
| auto c = new C2245; |
| assert(c.makecall() == 0); |
| assert(c.makecall(0) == 1); |
| assert(c.makecall(0,1) == 2); |
| |
| assert(c.makecall2() == 0); |
| assert(c.makecall2(0) == 1); |
| assert(c.makecall2(0,1) == 2); |
| |
| assert(c.makecall2!()() == 0); |
| assert(c.makecall2!(int)(0) == 1); |
| assert(c.makecall2!(int, int)(0,1) == 2); |
| |
| auto s = S2245(); |
| assert(s.makecall() == 0); |
| assert(s.makecall(0) == 1); |
| assert(s.makecall(0,1) == 2); |
| |
| assert(s.makecall2() == 0); |
| assert(s.makecall2(0) == 1); |
| assert(s.makecall2(0,1) == 2); |
| |
| assert(s.makecall2!()() == 0); |
| assert(s.makecall2!(int)(0) == 1); |
| assert(s.makecall2!(int, int)(0,1) == 2); |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2481 |
| |
| template M2481() { int i; } |
| class Z2481a { struct { mixin M2481!(); } } |
| class Z2481b { struct { int i; } } |
| |
| void test2481() |
| { |
| Z2481a z1; |
| Z2481b z2; |
| static assert(z1.i.offsetof == z2.i.offsetof); |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2740 |
| |
| interface IFooable2740 |
| { |
| bool foo(); |
| } |
| abstract class CFooable2740 |
| { |
| bool foo(); |
| } |
| |
| mixin template MFoo2740() |
| { |
| override bool foo() { return true; } |
| } |
| |
| class Foo2740i1 : IFooable2740 |
| { |
| override bool foo() { return false; } |
| mixin MFoo2740; |
| } |
| class Foo2740i2 : IFooable2740 |
| { |
| mixin MFoo2740; |
| override bool foo() { return false; } |
| } |
| |
| class Foo2740c1 : CFooable2740 |
| { |
| override bool foo() { return false; } |
| mixin MFoo2740; |
| } |
| class Foo2740c2 : CFooable2740 |
| { |
| mixin MFoo2740; |
| override bool foo() { return false; } |
| } |
| |
| void test2740() |
| { |
| { |
| auto p = new Foo2740i1(); |
| IFooable2740 i = p; |
| assert(p.foo() == false); |
| assert(i.foo() == false); |
| } |
| { |
| auto p = new Foo2740i2(); |
| IFooable2740 i = p; |
| assert(p.foo() == false); |
| assert(i.foo() == false); |
| } |
| |
| { |
| auto p = new Foo2740c1(); |
| CFooable2740 i = p; |
| assert(p.foo() == false); |
| assert(i.foo() == false); |
| } |
| { |
| auto p = new Foo2740c2(); |
| CFooable2740 i = p; |
| assert(p.foo() == false); |
| assert(i.foo() == false); |
| } |
| } |
| |
| /*******************************************/ |
| |
| mixin template MTestFoo() |
| { |
| int foo(){ return 2; } |
| } |
| class TestFoo |
| { |
| mixin MTestFoo!() test; |
| int foo(){ return 1; } |
| } |
| void test42() |
| { |
| auto p = new TestFoo(); |
| assert(p.foo() == 1); |
| assert(p.test.foo() == 2); |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7744 |
| |
| class ZeroOrMore7744(Expr) |
| { |
| enum name = "ZeroOrMore7744!("~Expr.name~")"; |
| } |
| class Range7744(char begin, char end) |
| { |
| enum name = "Range7744!("~begin~","~end~")"; |
| } |
| |
| mixin(q{ |
| class RubySource7744 : ZeroOrMore7744!(DecLiteral7744) |
| { |
| } |
| class DecLiteral7744 : Range7744!('0','9') |
| { |
| } |
| }); |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8032 |
| |
| mixin template T8032() |
| { |
| void f() { } |
| } |
| |
| class A8032a |
| { |
| mixin T8032; // Named mixin causes the error too |
| void f() { } |
| } |
| class B8032a : A8032a |
| { |
| override void f() { } |
| } |
| |
| class A8032b |
| { |
| void f() { } |
| mixin T8032; // Named mixin causes the error too |
| } |
| class B8032b : A8032b |
| { |
| override void f() { } |
| } |
| |
| /*********************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9417 |
| |
| mixin template Foo9417() |
| { |
| void foo() {} |
| } |
| |
| void test9417() |
| { |
| struct B |
| { |
| mixin Foo9417; |
| } |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11487 |
| |
| template X11487() |
| { |
| struct R() |
| { |
| C11487 c; |
| |
| ~this() |
| { |
| static assert(is(typeof(c.front) == void)); |
| } |
| } |
| template Mix(alias R) |
| { |
| R!() range; |
| @property front() inout {} |
| } |
| } |
| |
| class C11487 |
| { |
| alias X11487!() M; |
| mixin M.Mix!(M.R); |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11767 |
| |
| mixin template M11767() |
| { |
| struct S11767 {} |
| } |
| mixin M11767!(); |
| mixin M11767!(); // OK |
| static assert(!__traits(compiles, S11767)); |
| |
| void test11767() |
| { |
| mixin M11767!(); |
| alias S1 = S11767; |
| { |
| mixin M11767!(); |
| alias S2 = S11767; |
| static assert(!is(S1 == S2)); |
| static assert(S1.mangleof == "S6mixin19test11767FZ8__mixin16S11767"); |
| static assert(S2.mangleof == "S6mixin19test11767FZ8__mixin26S11767"); |
| } |
| mixin M11767!(); |
| static assert(!__traits(compiles, S11767)); |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12023 |
| |
| void Delete12023(Object obj) {} |
| |
| template MessageCode12023() |
| { |
| alias typeof(this) C; |
| |
| struct MessageDeinitHelper |
| { |
| C m_outer; |
| |
| ~this() |
| { |
| m_outer.DoDeinitMessaging(); |
| } |
| } |
| |
| CToClient toClient = null; |
| TypeTuple!(CToClient) toClients; |
| |
| class CToClient {} |
| |
| void DoDeinitMessaging() |
| { |
| Delete12023(toClient); |
| Delete12023(toClients); |
| } |
| } |
| |
| class TurretCannon12023(ProjectileClass) |
| { |
| mixin MessageCode12023; |
| } |
| |
| void test12023() |
| { |
| auto tc = new TurretCannon12023!Object(); |
| } |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14243 |
| |
| mixin template Mix14243a(int n) |
| { |
| static assert(n > 0); |
| import core.stdc.stdio; |
| enum { enumMember = 1 } |
| |
| auto a = A14243(n); |
| } |
| |
| mixin template Mix14243b(int n) |
| { |
| static if (n > 0) |
| { |
| auto b = A14243(n); |
| } |
| } |
| |
| template foo14243(alias v) { auto bar() { return &v; } } |
| mixin template Mix14243c(alias v) |
| { |
| // instantiate template in TemplateMixin |
| auto c = foo14243!v.bar(); |
| } |
| |
| mixin template Mix14243d(int n) |
| { |
| // Type declaration in TemplateMixin |
| struct NS { int x = n; } |
| mixin("auto d" ~ ('0' + n) ~ " = NS();"); |
| } |
| |
| mixin template Mix14243e(int n) |
| { |
| @safe: |
| nothrow: |
| int foo() { return var; } |
| |
| static: |
| struct S { int x; void f() {} } |
| int bar() { return n; } |
| } |
| |
| int test14243() |
| { |
| int[] ctor; |
| int[] dtor; |
| struct A14243 |
| { |
| int x; |
| this(int x) { ctor ~= x; this.x = x; } |
| ~this() { dtor ~= x; } |
| } |
| |
| { |
| /**/ |
| assert(ctor == [] && dtor == []); mixin Mix14243a!(1); |
| assert(ctor == [1] && dtor == []); mixin Mix14243b!(12) b1; |
| assert(ctor == [1,12] && dtor == []); mixin Mix14243b!(24) b2; |
| assert(ctor == [1,12,24] && dtor == []); |
| assert(a.x == 1); |
| static assert(!__traits(compiles, b > 0)); // ambiguous symbol access |
| assert(b1.b.x == 12); |
| assert(b2.b.x == 24); |
| |
| int x; |
| mixin Mix14243c!(x); |
| assert(c == &x); |
| |
| mixin Mix14243d!(1); |
| mixin Mix14243d!(2); |
| static assert(!is(typeof(d1) == typeof(d2))); |
| assert(d1.x == 1); |
| assert(d2.x == 2); |
| |
| assert(ctor == [1,12,24] && dtor == []); |
| } |
| assert(ctor == [1,12,24] && dtor == [24,12,1]); |
| |
| { |
| int var = 1; |
| mixin Mix14243e!12; |
| static assert(is(typeof(&foo) == int delegate() @safe nothrow pure @nogc)); |
| static assert(is(typeof(&bar) == int function() @safe nothrow pure @nogc)); |
| static assert(S.sizeof == int.sizeof); // s is static struct |
| assert(foo() == 1); |
| assert(bar() == 12); |
| } |
| return 1; |
| } |
| static assert(test14243()); // changed to be workable |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10492 |
| |
| class TestClass10492 {} |
| |
| mixin template mix10492(string name) |
| { |
| mixin("scope " ~ name ~ " = new TestClass10492;" ); |
| } |
| |
| void test10492() |
| { |
| mixin mix10492!("var"); |
| } |
| |
| /*******************************************/ |
| |
| int main() |
| { |
| test1(); |
| test2(); |
| test3(); |
| test4(); |
| test5(); |
| test6(); |
| test7(); |
| test8(); |
| test9(); |
| test10(); |
| test11(); |
| test12(); |
| test13(); |
| test14(); |
| test15(); |
| test16(); |
| test17(); |
| test18(); |
| test19(); |
| test20(); |
| test21(); |
| test22(); |
| test23(); |
| test24(); |
| test25(); |
| test26(); |
| test27(); |
| test28(); |
| test29(); |
| test30(); |
| test31(); |
| test32(); |
| test33(); |
| test34(); |
| test35(); |
| test36(); |
| test37(); |
| test38(); |
| test39(); |
| test40(); |
| test41(); |
| test2245(); |
| test2740(); |
| test42(); |
| test9417(); |
| test11767(); |
| test12023(); |
| test14243(); |
| test10492(); |
| |
| printf("Success\n"); |
| return 0; |
| } |
