| /* |
| REQUIRED_ARGS: -preview=rvaluerefparam |
| PERMUTE_ARGS: |
| EXTRA_FILES: imports/testmangle.d |
| TEST_OUTPUT: |
| --- |
| func |
| double |
| All good 1 |
| All good 2 |
| All good 3 |
| _D7imports10testmangle12detectMangleFPSQBlQBg6DetectZQq |
| _D7imports10testmangle__T10DetectTmplTiZQpFNaNbNiNfZv |
| true |
| false |
| uint |
| int[] |
| int[] |
| const(K5886) |
| 4 ; const(K5886) |
| 8 ; const(K5886) |
| K5886 |
| immutable(K5886) |
| 4 ; K5886 |
| 4 ; immutable(K5886) |
| 1 ; K5886 |
| 2 ; const(K5886) |
| 3 ; immutable(K5886) |
| 8 ; K5886 |
| 9 ; const(K5886) |
| 10 ; immutable(K5886) |
| > U = int, N:$?:64=ulong = 3LU|32=uint = 3u$ |
| K=string, V=int |
| K=char, V=string |
| T = SA, E = int, dim = $?:64=5LU|32=5u$ |
| T = DA, E = int |
| T = AA, K = string, V = int |
| pure nothrow @nogc @safe void(int t) |
| pure nothrow @nogc @safe void(int t) |
| T = byte |
| T = char |
| --- |
| |
| RUN_OUTPUT: |
| --- |
| typeof(T)=double typeof(S)=int |
| typeof(T)=double typeof(S)=int |
| typeof(T)=float typeof(S)=int |
| Success |
| --- |
| */ |
| |
| module breaker; |
| |
| import core.stdc.stdio, core.vararg; |
| |
| /**********************************/ |
| |
| U foo(T, U)(U i) |
| { |
| return i + 1; |
| } |
| |
| int foo(T)(int i) |
| { |
| return i + 2; |
| } |
| |
| void test1() |
| { |
| auto i = foo!(int)(2L); |
| // assert(i == 4); // now returns 3 |
| } |
| |
| /**********************************/ |
| |
| U foo2(T, U)(U i) |
| { |
| return i + 1; |
| } |
| |
| void test2() |
| { |
| auto i = foo2!(int)(2L); |
| assert(i == 3); |
| } |
| |
| /**********************************/ |
| |
| class Foo3 |
| { |
| T bar(T,U)(U u) |
| { |
| return cast(T)u; |
| } |
| } |
| |
| void test3() |
| { |
| Foo3 foo = new Foo3; |
| int i = foo.bar!(int)(1.0); |
| assert(i == 1); |
| } |
| |
| |
| /**********************************/ |
| |
| T* begin4(T)(T[] a) { return a.ptr; } |
| |
| void copy4(string pred = "", Ranges...)(Ranges rs) |
| { |
| alias rs[$ - 1] target; |
| pragma(msg, typeof(target).stringof); |
| auto tb = begin4(target);//, te = end(target); |
| } |
| |
| void test4() |
| { |
| int[] a, b, c; |
| copy4(a, b, c); |
| // comment the following line to prevent compiler from crashing |
| copy4!("a > 1")(a, b, c); |
| } |
| |
| /**********************************/ |
| |
| template foo5(T,S) |
| { |
| void foo5(T t, S s) { |
| const tstr = typeid(T).toString(); |
| const sstr = typeid(S).toString(); |
| printf("typeof(T)=%.*s typeof(S)=%.*s\n", |
| cast(int)tstr.length, tstr.ptr, cast(int)sstr.length, sstr.ptr); |
| } |
| } |
| |
| template bar5(T,S) |
| { |
| void bar5(S s) { |
| const tstr = typeid(T).toString(); |
| const sstr = typeid(S).toString(); |
| printf("typeof(T)=%.*s typeof(S)=%.*s\n", |
| cast(int)tstr.length, tstr.ptr, cast(int)sstr.length, sstr.ptr); |
| } |
| } |
| |
| |
| void test5() |
| { |
| foo5(1.0,33); |
| bar5!(double,int)(33); |
| bar5!(float)(33); |
| } |
| |
| /**********************************/ |
| |
| int foo6(T...)(auto ref T x) |
| { int result; |
| |
| foreach (i, v; x) |
| { |
| if (v == 10) |
| assert(__traits(isRef, x[i])); |
| else |
| assert(!__traits(isRef, x[i])); |
| result += v; |
| } |
| return result; |
| } |
| |
| void test6() |
| { int y = 10; |
| int r; |
| r = foo6(8); |
| assert(r == 8); |
| r = foo6(y); |
| assert(r == 10); |
| r = foo6(3, 4, y); |
| assert(r == 17); |
| r = foo6(4, 5, y); |
| assert(r == 19); |
| r = foo6(y, 6, y); |
| assert(r == 26); |
| } |
| |
| /**********************************/ |
| |
| auto ref min(T, U)(auto ref T lhs, auto ref U rhs) |
| { |
| return lhs > rhs ? rhs : lhs; |
| } |
| |
| void test7() |
| { int x = 7, y = 8; |
| int i; |
| |
| i = min(4, 3); |
| assert(i == 3); |
| i = min(x, y); |
| assert(i == 7); |
| min(x, y) = 10; |
| assert(x == 10); |
| static assert(!__traits(compiles, min(3, y) = 10)); |
| static assert(!__traits(compiles, min(y, 3) = 10)); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5946 |
| |
| template TTest8() |
| { |
| int call(){ return this.g(); } |
| } |
| class CTest8 |
| { |
| int f() { mixin TTest8!(); return call(); } |
| int g() { return 10; } |
| } |
| void test8() |
| { |
| assert((new CTest8()).f() == 10); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=693 |
| |
| template TTest9(alias sym) |
| { |
| int call(){ return sym.g(); } |
| } |
| class CTest9 |
| { |
| int f1() { mixin TTest9!(this); return call(); } |
| int f2() { mixin TTest9!this; return call(); } |
| int g() { return 10; } |
| } |
| void test9() |
| { |
| assert((new CTest9()).f1() == 10); |
| assert((new CTest9()).f2() == 10); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=1780 |
| |
| template Tuple1780(Ts ...) { alias Ts Tuple1780; } |
| |
| template Decode1780( T ) { alias Tuple1780!() Types; } |
| template Decode1780( T : TT!(Us), alias TT, Us... ) { alias Us Types; } |
| |
| void test1780() |
| { |
| struct S1780(T1, T2) {} |
| |
| // should extract tuple (bool,short) but matches the first specialisation |
| alias Decode1780!( S1780!(bool,short) ).Types SQ1780; // --> SQ2 is empty tuple! |
| static assert(is(SQ1780 == Tuple1780!(bool, short))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=1659 |
| |
| class Foo1659 { } |
| class Bar1659 : Foo1659 { } |
| |
| void f1659(T : Foo1659)() { } |
| void f1659(alias T)() { static assert(false); } |
| |
| void test1659() |
| { |
| f1659!Bar1659(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2025 |
| |
| struct S2025 {} |
| void f2025() {} |
| |
| template Foo2025(int i) { enum Foo2025 = 1; } |
| template Foo2025(TL...) { enum Foo2025 = 2; } |
| static assert(Foo2025!1 == 1); |
| static assert(Foo2025!int == 2); |
| static assert(Foo2025!S2025 == 2); |
| static assert(Foo2025!f2025 == 2); |
| |
| template Bar2025(T) { enum Bar2025 = 1; } |
| template Bar2025(A...) { enum Bar2025 = 2; } |
| static assert(Bar2025!1 == 2); |
| static assert(Bar2025!int == 1); // 2 -> 1 |
| static assert(Bar2025!S2025 == 1); // 2 -> 1 |
| static assert(Bar2025!f2025 == 2); |
| |
| template Baz2025(T) { enum Baz2025 = 1; } |
| template Baz2025(alias A) { enum Baz2025 = 2; } |
| static assert(Baz2025!1 == 2); |
| static assert(Baz2025!int == 1); |
| static assert(Baz2025!S2025 == 1); // 2 -> 1 |
| static assert(Baz2025!f2025 == 2); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=3608 |
| |
| template foo3608(T, U){} |
| |
| template BaseTemplate3608(alias TTT : U!V, alias U, V...) |
| { |
| alias U BaseTemplate3608; |
| } |
| template TemplateParams3608(alias T : U!V, alias U, V...) |
| { |
| alias V TemplateParams3608; |
| } |
| |
| template TyueTuple3608(T...) { alias T TyueTuple3608; } |
| |
| void test3608() |
| { |
| alias foo3608!(int, long) Foo3608; |
| |
| static assert(__traits(isSame, BaseTemplate3608!Foo3608, foo3608)); |
| static assert(is(TemplateParams3608!Foo3608 == TyueTuple3608!(int, long))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5015 |
| |
| import breaker; |
| |
| static if (is(ElemType!(int))){} |
| |
| template ElemType(T) { |
| alias _ElemType!(T).type ElemType; |
| } |
| |
| template _ElemType(T) { |
| alias r type; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5185 |
| |
| class C5185(V) |
| { |
| void f() |
| { |
| C5185!(C5185!(int)) c; |
| } |
| } |
| |
| void test5185() |
| { |
| C5185!(C5185!(int)) c; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5893 |
| |
| class C5893 |
| { |
| int concatAssign(C5893 other) { return 1; } |
| int concatAssign(int other) { return 2; } // to demonstrate overloading |
| |
| template opOpAssign(string op) if (op == "~") |
| { alias concatAssign opOpAssign; } |
| |
| int opOpAssign(string op)(int other) if (op == "+") { return 3; } |
| } |
| |
| void test5893() |
| { |
| auto c = new C5893; |
| assert(c.opOpAssign!"~"(c) == 1); // works |
| assert(c.opOpAssign!"~"(1) == 2); // works |
| assert((c ~= 1) == 2); |
| assert((c += 1) == 3); // overload |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5988 |
| |
| template Templ5988(alias T) |
| { |
| alias T!int Templ5988; |
| } |
| |
| class C5988a(T) { Templ5988!C5988a foo; } |
| //Templ5988!C5988a foo5988a; // Commented version |
| void test5988a() { C5988a!int a; } // Was error, now works |
| |
| class C5988b(T) { Templ5988!C5988b foo; } |
| Templ5988!C5988b foo5988b; // Uncomment version |
| void test5988b() { C5988b!int a; } // Works |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6404 |
| |
| // receive only rvalue |
| void rvalue(T)(auto ref T x) if (!__traits(isRef, x)) {} |
| void rvalueVargs(T...)(auto ref T x) if (!__traits(isRef, x[0])) {} |
| |
| // receive only lvalue |
| void lvalue(T)(auto ref T x) if ( __traits(isRef, x)) {} |
| void lvalueVargs(T...)(auto ref T x) if ( __traits(isRef, x[0])) {} |
| |
| void test6404() |
| { |
| int n; |
| |
| static assert(!__traits(compiles, rvalue(n))); |
| static assert( __traits(compiles, rvalue(0))); |
| |
| static assert( __traits(compiles, lvalue(n))); |
| static assert(!__traits(compiles, lvalue(0))); |
| |
| static assert(!__traits(compiles, rvalueVargs(n))); |
| static assert( __traits(compiles, rvalueVargs(0))); |
| |
| static assert( __traits(compiles, lvalueVargs(n))); |
| static assert(!__traits(compiles, lvalueVargs(0))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2246 |
| |
| class A2246(T,d){ |
| T p; |
| } |
| |
| class B2246(int rk){ |
| int[rk] p; |
| } |
| |
| class C2246(T,int rk){ |
| T[rk] p; |
| } |
| |
| template f2246(T:A2246!(U,d),U,d){ |
| void f2246(){ } |
| } |
| |
| template f2246(T:B2246!(rank),int rank){ |
| void f2246(){ } |
| } |
| |
| template f2246(T:C2246!(U,rank),U,int rank){ |
| void f2246(){ } |
| } |
| |
| void test2246(){ |
| A2246!(int,long) a; |
| B2246!(2) b; |
| C2246!(int,2) c; |
| f2246!(A2246!(int,long))(); |
| f2246!(B2246!(2))(); |
| f2246!(C2246!(int,2))(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2296 |
| |
| void foo2296(size_t D)(int[D] i...){} |
| void test2296() |
| { |
| foo2296(1, 2, 3); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=1684 |
| |
| template Test1684( uint memberOffset ){} |
| |
| class MyClass1684 { |
| int flags2; |
| mixin Test1684!(cast(uint)flags2.offsetof) t1; // compiles ok |
| mixin Test1684!(cast(int)flags2.offsetof) t2; // compiles ok |
| mixin Test1684!(flags2.offsetof) t3; // Error: no property 'offsetof' for type 'int' |
| } |
| |
| /**********************************/ |
| |
| void bug4984a(int n)() if (n > 0 && is(typeof(bug4984a!(n-1) ()))) { |
| } |
| |
| void bug4984a(int n : 0)() { |
| } |
| |
| void bug4984b(U...)(U args) if ( is(typeof( bug4984b(args[1..$]) )) ) { |
| } |
| |
| void bug4984b(U)(U u) { |
| } |
| |
| void bug4984() { |
| // Note: compiling this overflows the stack if dmd is build with DEBUG |
| //bug4984a!400(); |
| bug4984a!200(); |
| bug4984b(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19); |
| } |
| |
| /***************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2579 |
| |
| void foo2579(T)(T delegate(in Object) dlg) |
| { |
| } |
| |
| void test2579() |
| { |
| foo2579( (in Object o) { return 15; } ); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2803 |
| |
| auto foo2803(T)(T t = 0) { return t; } |
| |
| struct S2803 {} |
| S2803 s2803; |
| ref S2803 getS2803() { return s2803; } |
| auto fun2803(T, U)(T t, ref U u = getS2803) |
| { |
| static assert(is(U == S2803)); |
| return &u; |
| } |
| |
| // from the past version of std.conv |
| template to2803(T) { T to2803(S)(S src) { return T.init; } } |
| auto toImpl2803a(T, S)(S s, in T left, in T sep = ", ", in T right = "]") {} |
| auto toImpl2803b(T, S)(S s, in T left = to2803!T(S.stringof~"("), in T right = ")") {} |
| auto toImpl2803c(T, S)(S s, in T left = S.stringof~"(" , in T right = ")") {} // combination with enh 13944 |
| |
| // from std.range.package in 2.067a. |
| auto enumerate2803(En = size_t, R)(R r, En start = 0) |
| { |
| // The type of 'start' should be size_t, it's the defaultArg of En, |
| // rather than the deduced type from its defualtArg '0'. |
| static assert(is(typeof(start) == size_t)); |
| return start; |
| } |
| |
| // from std.numeric. |
| alias ElementType2803(R) = typeof(R.init[0].init); |
| void normalize2803(R)(R range, ElementType2803!R sum = 1) |
| { |
| // The type of 'sum' should be determined to ElementType!(double[]) == double |
| // before the type deduction from its defaultArg '1'. |
| static assert(is(typeof(sum) == double)); |
| } |
| |
| auto foo14468(T)(T[]...) { return 1; } |
| auto foo14468(bool flag, T)(T[]...) { return 2; } |
| |
| void test2803() |
| { |
| assert(foo2803() == 0); |
| assert(foo2803(1) == 1); |
| |
| S2803 s; |
| assert(fun2803(1) is &s2803); |
| assert(fun2803(1, s) is &s); |
| |
| // regression cases |
| |
| toImpl2803a!string(1, "["); |
| |
| toImpl2803b! string(1); |
| toImpl2803b!wstring(1); |
| toImpl2803b!dstring(1); |
| |
| toImpl2803c! string(1); |
| toImpl2803c!wstring(1); // requires enhancement 13944 |
| toImpl2803c!dstring(1); // requires enhancement 13944 |
| |
| enumerate2803([1]); |
| |
| double[] a = []; |
| normalize2803(a); |
| |
| assert(foo14468!int() == 1); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6613 |
| |
| alias Tuple6613(T...) = T; |
| |
| void f6613(T...)(int x = 0, T xs = Tuple6613!()) |
| { |
| assert(x == 0); |
| static assert(T.length == 0); |
| } |
| |
| void test6613() |
| { |
| f6613(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=4953 |
| |
| void bug4953(T = void)(short x) {} |
| static assert(is(typeof(bug4953(3)))); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5886 |
| // https://issues.dlang.org/show_bug.cgi?id=5393 |
| |
| mixin template Foo5886(T) |
| { |
| void foo(U : T, this X)() const { static assert(is(X == const K5886)); } |
| } |
| |
| struct K5886 |
| { |
| void get1(this T)() const |
| { |
| pragma(msg, T); |
| } |
| void get2(int N=4, this T)() const |
| { |
| pragma(msg, N, " ; ", T); |
| } |
| |
| mixin Foo5886!double; |
| mixin Foo5886!string; |
| |
| void test() const |
| { |
| get1; // OK |
| get2; // OK |
| get2!8; // NG |
| |
| foo!(int); |
| foo!(typeof(null)); |
| } |
| } |
| |
| void test5886() |
| { |
| K5886 km; |
| const(K5886) kc; |
| immutable(K5886) ki; |
| |
| km.get1; // OK |
| kc.get1; // OK |
| ki.get1; // OK |
| km.get2; // OK |
| kc.get2; // OK |
| ki.get2; // OK |
| km.get2!(1, K5886); // Ugly |
| kc.get2!(2, const(K5886)); // Ugly |
| ki.get2!(3, immutable(K5886)); // Ugly |
| km.get2!8; // Error |
| kc.get2!9; // Error |
| ki.get2!10; // Error |
| } |
| |
| // -------- |
| |
| void test5393() |
| { |
| class A |
| { |
| void opDispatch (string name, this T) () { } |
| } |
| |
| class B : A {} |
| |
| auto b = new B; |
| b.foobar(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5896 |
| |
| struct X5896 |
| { |
| T opCast(T)(){ return 1; } |
| const T opCast(T)(){ return 2; } |
| immutable T opCast(T)(){ return 3; } |
| shared T opCast(T)(){ return 4; } |
| const shared T opCast(T)(){ return 5; } |
| } |
| void test5896() |
| { |
| auto xm = X5896 (); |
| auto xc = const(X5896) (); |
| auto xi = immutable(X5896) (); |
| auto xs = shared(X5896) (); |
| auto xcs= const(shared(X5896))(); |
| assert(cast(int)xm == 1); |
| assert(cast(int)xc == 2); |
| assert(cast(int)xi == 3); |
| assert(cast(int)xs == 4); |
| assert(cast(int)xcs== 5); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6312 |
| |
| void h6312() {} |
| |
| class Bla6312 |
| { |
| mixin wrap6312!h6312; |
| } |
| |
| mixin template wrap6312(alias f) |
| { |
| void blub(alias g = f)() |
| { |
| g(); |
| } |
| } |
| |
| void test6312() |
| { |
| Bla6312 b = new Bla6312(); |
| b.blub(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6825 |
| |
| void test6825() |
| { |
| struct File |
| { |
| void write(S...)(S args) {} |
| } |
| |
| void dump(void delegate(string) d) {} |
| |
| auto o = File(); |
| dump(&o.write!string); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6789 |
| |
| template isStaticArray6789(T) |
| { |
| static if (is(T U : U[N], size_t N)) // doesn't match |
| { |
| pragma(msg, "> U = ", U, ", N:", typeof(N), " = ", N); |
| enum isStaticArray6789 = true; |
| } |
| else |
| enum isStaticArray6789 = false; |
| } |
| |
| void test6789() |
| { |
| alias int[3] T; |
| static assert(isStaticArray6789!T); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2778 |
| |
| struct ArrayWrapper2778(T) |
| { |
| T[] data; |
| alias data this; |
| } |
| |
| void doStuffFunc2778(int[] data) {} |
| |
| void doStuffTempl2778(T)(T[] data) {} |
| |
| int doStuffTemplOver2778(T)(void* data) { return 1; } |
| int doStuffTemplOver2778(T)(ArrayWrapper2778!T w) { return 2; } |
| |
| void test2778() |
| { |
| ArrayWrapper2778!(int) foo; |
| |
| doStuffFunc2778(foo); // Works. |
| |
| doStuffTempl2778!(int)(foo); // Works. |
| |
| doStuffTempl2778(foo); // Error |
| |
| assert(doStuffTemplOver2778(foo) == 2); |
| } |
| |
| // ---- |
| |
| void test2778aa() |
| { |
| void foo(K, V)(V[K] aa){ pragma(msg, "K=", K, ", V=", V); } |
| |
| int[string] aa1; |
| foo(aa1); // OK |
| |
| struct SubTypeOf(T) |
| { |
| T val; |
| alias val this; |
| } |
| SubTypeOf!(string[char]) aa2; |
| foo(aa2); // NG |
| } |
| |
| // ---- |
| |
| void test2778get() |
| { |
| void foo(ubyte[]){} |
| |
| static struct S |
| { |
| ubyte[] val = [1,2,3]; |
| @property ref ubyte[] get() return { return val; } |
| alias get this; |
| } |
| S s; |
| foo(s); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6208 |
| |
| int getRefNonref(T)(ref T s){ return 1; } |
| int getRefNonref(T)( T s){ return 2; } |
| |
| int getAutoRef(T)(auto ref T s){ return __traits(isRef, s) ? 1 : 2; } |
| |
| void getOut(T)(out T s){ {} } |
| |
| void getLazy1(T=int)(lazy void s){ s(), s(); } |
| void getLazy2(T)(lazy T s){ s(), s(); } |
| |
| void test6208a() |
| { |
| int lvalue; |
| int rvalue(){ int t; return t; } |
| |
| assert(getRefNonref(lvalue ) == 1); |
| assert(getRefNonref(rvalue()) == 2); |
| |
| assert(getAutoRef(lvalue ) == 1); |
| assert(getAutoRef(rvalue()) == 2); |
| |
| static assert( __traits(compiles, getOut(lvalue ))); |
| static assert(!__traits(compiles, getOut(rvalue()))); |
| |
| int n1; getLazy1(++n1); assert(n1 == 2); |
| int n2; getLazy2(++n2); assert(n2 == 2); |
| |
| struct X |
| { |
| int f(T)(auto ref T t){ return 1; } |
| int f(T)(auto ref T t, ...){ return -1; } |
| } |
| auto xm = X (); |
| auto xc = const(X)(); |
| int n; |
| assert(xm.f!int(n) == 1); // resolved 'auto ref' |
| assert(xm.f!int(0) == 1); // ditto |
| } |
| |
| void test6208b() |
| { |
| void foo(T)(const T value) if (!is(T == int)) {} |
| |
| int mn; |
| const int cn; |
| static assert(!__traits(compiles, foo(mn))); // OK -> OK |
| static assert(!__traits(compiles, foo(cn))); // NG -> OK |
| } |
| |
| void test6208c() |
| { |
| struct S |
| { |
| // Original test case. |
| int foo(V)(in V v) { return 1; } |
| int foo(Args...)(auto ref const Args args) { return 2; } |
| |
| // Reduced test cases |
| |
| int hoo(V)(const V v) { return 1; } // typeof(10) : const V -> MATCHconst |
| int hoo(Args...)(const Args args) { return 2; } // typeof(10) : const Args[0] -> MATCHconst |
| // If deduction matching level is same, tuple parameter is less specialized than others. |
| |
| int bar(V)(V v) { return 1; } // typeof(10) : V -> MATCHexact |
| int bar(Args...)(const Args args) { return 2; } // typeof(10) : const Args[0] -> MATCHconst |
| |
| int baz(V)(const V v) { return 1; } // typeof(10) : const V -> MATCHconst |
| int baz(Args...)(Args args) { return 2; } // typeof(10) : Args[0] -> MATCHexact |
| |
| inout(int) war(V)(inout V v) { return 1; } |
| inout(int) war(Args...)(inout Args args){ return 2; } |
| |
| inout(int) waz(Args...)(inout Args args){ return 0; } // wild deduction test |
| } |
| |
| S s; |
| |
| int nm = 10; |
| assert(s.foo(nm) == 1); |
| assert(s.hoo(nm) == 1); |
| assert(s.bar(nm) == 1); |
| assert(s.baz(nm) == 2); |
| assert(s.war(nm) == 1); |
| static assert(is(typeof(s.waz(nm)) == int)); |
| |
| const int nc = 10; |
| assert(s.foo(nc) == 1); |
| assert(s.hoo(nc) == 1); |
| assert(s.bar(nc) == 1); |
| assert(s.baz(nc) == 1); |
| assert(s.war(nc) == 1); |
| static assert(is(typeof(s.waz(nc)) == const(int))); |
| |
| immutable int ni = 10; |
| assert(s.foo(ni) == 1); |
| assert(s.hoo(ni) == 1); |
| assert(s.bar(ni) == 1); |
| assert(s.baz(ni) == 2); |
| assert(s.war(ni) == 1); |
| static assert(is(typeof(s.waz(ni)) == immutable(int))); |
| |
| static assert(is(typeof(s.waz(nm, nm)) == int)); |
| static assert(is(typeof(s.waz(nm, nc)) == const(int))); |
| static assert(is(typeof(s.waz(nm, ni)) == const(int))); |
| static assert(is(typeof(s.waz(nc, nm)) == const(int))); |
| static assert(is(typeof(s.waz(nc, nc)) == const(int))); |
| static assert(is(typeof(s.waz(nc, ni)) == const(int))); |
| static assert(is(typeof(s.waz(ni, nm)) == const(int))); |
| static assert(is(typeof(s.waz(ni, nc)) == const(int))); |
| static assert(is(typeof(s.waz(ni, ni)) == immutable(int))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6805 |
| |
| struct T6805 |
| { |
| template opDispatch(string name) |
| { |
| alias int Type; |
| } |
| } |
| static assert(is(T6805.xxx.Type == int)); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6738 |
| |
| struct Foo6738 |
| { |
| int _val = 10; |
| |
| @property int val()() { return _val; } |
| int get() { return val; } // fail |
| } |
| |
| void test6738() |
| { |
| Foo6738 foo; |
| auto x = foo.val; // ok |
| assert(x == 10); |
| assert(foo.get() == 10); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7498 |
| |
| template IndexMixin(){ |
| void insert(T)(T value){ } |
| } |
| |
| class MultiIndexContainer{ |
| mixin IndexMixin!() index0; |
| class Index0{ |
| void baburk(){ |
| this.outer.index0.insert(1); |
| } |
| } |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6780 |
| |
| @property int foo6780()(){ return 10; } |
| |
| int g6780; |
| @property void bar6780()(int n){ g6780 = n; } |
| |
| void test6780() |
| { |
| auto n = foo6780; |
| assert(n == 10); |
| |
| bar6780 = 10; |
| assert(g6780 == 10); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6810 |
| |
| int f6810(int n)(int) { return 1;} |
| int f6810(U...)(U) { assert(0); } |
| int f6810(U...)(U a) { assert(0); } |
| int f6810(U...)(U) if (true) { assert(0); } |
| int f6810(U...)(U a) if (true) { assert(0); } |
| |
| void test6810() |
| { |
| assert(f6810!0(0) == 1); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6891 |
| |
| struct S6891(int N, T) |
| { |
| void f(U)(S6891!(N, U) u) { } |
| } |
| |
| void test6891() |
| { |
| alias S6891!(1, void) A; |
| A().f(A()); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6994 |
| |
| struct Foo6994 |
| { |
| T get(T)(){ return T.init; } |
| |
| T func1(T)() |
| if (__traits(compiles, get!T())) |
| { return get!T; } |
| |
| T func2(T)() |
| if (__traits(compiles, this.get!T())) // add explicit 'this' |
| { return get!T; } |
| } |
| void test6994() |
| { |
| Foo6994 foo; |
| foo.get!int(); // OK |
| foo.func1!int(); // OK |
| foo.func2!int(); // NG |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6764 |
| |
| enum N6764 = 1; //use const for D1 |
| |
| alias size_t[N6764] T6764; //workaround |
| void f6764()(T6764 arr...) { } |
| |
| void g6764()(size_t[1] arr...) { } |
| |
| void h6764()(size_t[N6764] arr...) { } |
| |
| void test6764() |
| { |
| f6764(0); //good |
| g6764(0); //good |
| h6764!()(0); //good |
| h6764(0); //Error: template main.f() does not match any function template declaration |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=3467 |
| // https://issues.dlang.org/show_bug.cgi?id=6806 |
| |
| struct Foo3467( uint n ) |
| { |
| Foo3467!( n ) bar( ) { |
| typeof( return ) result; |
| return result; |
| } |
| } |
| struct Vec3467(size_t N) |
| { |
| void opBinary(string op:"~", size_t M)(Vec3467!M) {} |
| } |
| void test3467() |
| { |
| Foo3467!( 4 ) baz; |
| baz = baz.bar;// FAIL |
| |
| Vec3467!2 a1; |
| Vec3467!3 a2; |
| a1 ~ a2; // line 7, Error |
| } |
| |
| struct TS6806(uint n) { pragma(msg, typeof(n)); } |
| static assert(is(TS6806!(1u) == TS6806!(1))); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=4413 |
| |
| struct Foo4413 |
| { |
| alias typeof(this) typeof_this; |
| void bar1(typeof_this other) {} |
| void bar2()(typeof_this other) {} |
| void bar3(typeof(this) other) {} |
| void bar4()(typeof(this) other) {} |
| } |
| |
| void test4413() |
| { |
| Foo4413 f; |
| f.bar1(f); // OK |
| f.bar2(f); // OK |
| f.bar3(f); // OK |
| f.bar4(f); // ERR |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=4675 |
| |
| template isNumeric(T) |
| { |
| enum bool test1 = is(T : long); // should be hidden |
| enum bool test2 = is(T : real); // should be hidden |
| enum bool isNumeric = test1 || test2; |
| } |
| void test4675() |
| { |
| static assert( isNumeric!int); |
| static assert(!isNumeric!string); |
| static assert(!__traits(compiles, isNumeric!int.test1)); // should be an error |
| static assert(!__traits(compiles, isNumeric!int.test2)); // should be an error |
| static assert(!__traits(compiles, isNumeric!int.isNumeric)); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5525 |
| |
| template foo5525(T) |
| { |
| T foo5525(T t) { return t; } |
| T foo5525(T t, T u) { return t + u; } |
| } |
| |
| void test5525() |
| { |
| alias foo5525!int f; |
| assert(f(1) == 1); |
| assert(f(1, 2) == 3); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5801 |
| |
| int a5801; |
| void bar5801(T = double)(typeof(a5801) i) {} |
| void baz5801(T)(typeof(a5801) i, T t) {} |
| void test5801() |
| { |
| bar5801(2); // Does not compile. |
| baz5801(3, "baz"); // Does not compile. |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=5832 |
| |
| struct Bar5832(alias v) {} |
| |
| template isBar5832a(T) |
| { |
| static if (is(T _ : Bar5832!(v), alias v)) |
| enum isBar5832a = true; |
| else |
| enum isBar5832a = false; |
| } |
| template isBar5832b(T) |
| { |
| static if (is(T _ : Bar5832!(v), alias int v)) |
| enum isBar5832b = true; |
| else |
| enum isBar5832b = false; |
| } |
| template isBar5832c(T) |
| { |
| static if (is(T _ : Bar5832!(v), alias string v)) |
| enum isBar5832c = true; |
| else |
| enum isBar5832c = false; |
| } |
| static assert( isBar5832a!(Bar5832!1234)); |
| static assert( isBar5832b!(Bar5832!1234)); |
| static assert(!isBar5832c!(Bar5832!1234)); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=2550 |
| |
| template pow10_2550(long n) |
| { |
| const long pow10_2550 = 0; |
| static if (n < 0) |
| const long pow10_2550 = 0; |
| else |
| const long pow10_2550 = 10 * pow10_2550!(n - 1); |
| } |
| template pow10_2550(long n:0) |
| { |
| const long pow10_2550 = 1; |
| } |
| static assert(pow10_2550!(0) == 1); |
| |
| /**********************************/ |
| // [2.057] Remove top const in IFTI, 9198 |
| |
| void foo10a(T )(T) { static assert(is(T == const(int)[])); } |
| void foo10b(T...)(T) { static assert(is(T[0] == const(int)[])); } |
| |
| // ref parameter doesn't remove top const |
| void boo10a(T )(ref T) { static assert(is(T == const(int[]))); } |
| void boo10b(T...)(ref T) { static assert(is(T[0] == const(int[]))); } |
| |
| // auto ref with lvalue doesn't |
| void goo10a(T )(auto ref T) { static assert(is(T == const(int[]))); } |
| void goo10b(T...)(auto ref T) { static assert(is(T[0] == const(int[]))); } |
| |
| // auto ref with rvalue does |
| void hoo10a(T )(auto ref T) { static assert(is(T == const(int)[])); } |
| void hoo10b(T...)(auto ref T) { static assert(is(T[0] == const(int)[])); } |
| |
| void bar10a(T )(T) { static assert(is(T == const(int)*)); } |
| void bar10b(T...)(T) { static assert(is(T[0] == const(int)*)); } |
| |
| void test10() |
| { |
| const a = [1,2,3]; |
| static assert(is(typeof(a) == const(int[]))); |
| foo10a(a); |
| foo10b(a); |
| boo10a(a); |
| boo10b(a); |
| goo10a(a); |
| goo10b(a); |
| hoo10a(cast(const)[1,2,3]); |
| hoo10b(cast(const)[1,2,3]); |
| |
| int n; |
| const p = &n; |
| static assert(is(typeof(p) == const(int*))); |
| bar10a(p); |
| bar10b(p); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=3092 |
| |
| template Foo3092(A...) |
| { |
| alias A[0] Foo3092; |
| } |
| static assert(is(Foo3092!(int, "foo") == int)); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7037 |
| |
| struct Foo7037 {} |
| struct Bar7037 { Foo7037 f; alias f this; } |
| void works7037( T )( T value ) if ( is( T : Foo7037 ) ) {} |
| void doesnotwork7037( T : Foo7037 )( T value ) {} |
| |
| void test7037() |
| { |
| Bar7037 b; |
| works7037( b ); |
| doesnotwork7037( b ); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7110 |
| |
| struct S7110 |
| { |
| int opSlice(int, int) const { return 0; } |
| int opSlice() const { return 0; } |
| int opIndex(int, int) const { return 0; } |
| int opIndex(int) const { return 0; } |
| } |
| |
| enum e7110 = S7110(); |
| |
| template T7110(alias a) { } // or T7110(a...) |
| |
| alias T7110!( S7110 ) T71100; // passes |
| alias T7110!((S7110)) T71101; // passes |
| |
| alias T7110!( S7110()[0..0] ) A0; // passes |
| alias T7110!( (e7110[0..0]) ) A1; // passes |
| alias T7110!( e7110[0..0] ) A2; // passes |
| |
| alias T7110!( S7110()[0, 0] ) B0; // passes |
| alias T7110!( (e7110[0, 0]) ) B1; // passes |
| alias T7110!( e7110[0, 0] ) B2; // passes |
| |
| alias T7110!( S7110()[] ) C0; // passes |
| alias T7110!( (e7110[]) ) C1; // passes |
| alias T7110!( e7110[] ) C2; // fails: e7110 is used as a type |
| |
| alias T7110!( S7110()[0] ) D0; // passes |
| alias T7110!( (e7110[0]) ) D1; // passes |
| alias T7110!( e7110[0] ) D2; // fails: e7110 must be an array or pointer type, not S7110 |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7124 |
| |
| template StaticArrayOf(T : E[dim], E, size_t dim) |
| { |
| pragma(msg, "T = ", T, ", E = ", E, ", dim = ", dim); |
| alias E[dim] StaticArrayOf; |
| } |
| |
| template DynamicArrayOf(T : E[], E) |
| { |
| pragma(msg, "T = ", T, ", E = ", E); |
| alias E[] DynamicArrayOf; |
| } |
| |
| template AssocArrayOf(T : V[K], K, V) |
| { |
| pragma(msg, "T = ", T, ", K = ", K, ", V = ", V); |
| alias V[K] AssocArrayOf; |
| } |
| void test7124() |
| { |
| struct SA { int[5] sa; alias sa this; } |
| static assert(is(StaticArrayOf!SA == int[5])); |
| |
| struct DA { int[] da; alias da this; } |
| static assert(is(DynamicArrayOf!DA == int[])); |
| |
| struct AA { int[string] aa; alias aa this; } |
| static assert(is(AssocArrayOf!AA == int[string])); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7359 |
| |
| bool foo7359(T)(T[] a ...) |
| { |
| return true; |
| } |
| |
| void test7359() |
| { |
| assert(foo7359(1,1,1,1,1,1)); // OK |
| assert(foo7359("abc","abc","abc","abc")); // NG |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7363 |
| |
| template t7363() |
| { |
| enum e = 0; |
| static if (true) |
| enum t7363 = 0; |
| } |
| static assert(!__traits(compiles, t7363!().t7363 == 0)); // Assertion fails |
| static assert(t7363!() == 0); // Error: void has no value |
| |
| template u7363() |
| { |
| static if (true) |
| { |
| enum e = 0; |
| enum u73631 = 0; |
| } |
| alias u73631 u7363; |
| } |
| static assert(!__traits(compiles, u7363!().u7363 == 0)); // Assertion fails |
| static assert(u7363!() == 0); // Error: void has no value |
| |
| /**********************************/ |
| |
| struct S4371(T ...) { } |
| |
| alias S4371!("hi!") t; |
| |
| static if (is(t U == S4371!(U))) { } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7416 |
| |
| void t7416(alias a)() if(is(typeof(a()))) |
| {} |
| |
| void test7416() { |
| void f() {} |
| alias t7416!f x; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7563 |
| |
| class Test7563 |
| { |
| void test(T, bool a = true)(T t) |
| { |
| |
| } |
| } |
| |
| void test7563() |
| { |
| auto test = new Test7563; |
| pragma(msg, typeof(test.test!(int, true)).stringof); |
| pragma(msg, typeof(test.test!(int)).stringof); // Error: expression (test.test!(int)) has no type |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7572 |
| |
| class F7572 |
| { |
| Tr fn7572(Tr, T...)(T t) { return 1; } |
| } |
| Tr Fn7572(Tr, T...)(T t) { return 2; } |
| |
| void test7572() |
| { |
| F7572 f = new F7572(); |
| int delegate() dg = &f.fn7572!int; |
| assert(dg() == 1); |
| |
| int function() fn = &Fn7572!int; |
| assert(fn() == 2); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7580 |
| |
| struct S7580(T) |
| { |
| void opAssign()(T value) {} |
| } |
| struct X7580(T) |
| { |
| private T val; |
| @property ref inout(T) get()() inout { return val; } // template |
| alias get this; |
| } |
| struct Y7580(T) |
| { |
| private T val; |
| @property ref auto get()() inout { return val; } // template + auto return |
| alias get this; |
| } |
| |
| void test7580() |
| { |
| S7580!(int) s; |
| X7580!int x; |
| Y7580!int y; |
| s = x; |
| s = y; |
| |
| shared(X7580!int) sx; |
| static assert(!__traits(compiles, s = sx)); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7585 |
| |
| extern(C) alias void function() Callback; |
| |
| template W7585a(alias dg) |
| { |
| //pragma(msg, typeof(dg)); |
| extern(C) void W7585a() { dg(); } |
| } |
| |
| void test7585() |
| { |
| static void f7585a(){} |
| Callback cb1 = &W7585a!(f7585a); // OK |
| static assert(!__traits(compiles, |
| { |
| void f7585b(){} |
| Callback cb2 = &W7585a!(f7585b); // NG |
| })); |
| |
| Callback cb3 = &W7585a!((){}); // NG -> OK |
| Callback cb4 = &W7585a!(function(){}); // OK |
| static assert(!__traits(compiles, |
| { |
| Callback cb5 = &W7585a!(delegate(){}); // NG |
| })); |
| |
| static int global; // global data |
| Callback cb6 = &W7585a!((){return global;}); // NG -> OK |
| static assert(!__traits(compiles, |
| { |
| int n; |
| Callback cb7 = &W7585a!((){return n;}); // NG |
| })); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7643 |
| |
| template T7643(A...){ alias A T7643; } |
| |
| alias T7643!(long, "x", string, "y") Specs7643; |
| |
| alias T7643!( Specs7643[] ) U7643; // Error: tuple A is used as a type |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7671 |
| |
| inout(int)[3] id7671n1 ( inout(int)[3] ); |
| inout( U )[n] id7671x1(U, size_t n)( inout( U )[n] ); |
| |
| shared(inout int)[3] id7671n2 ( shared(inout int)[3] ); |
| shared(inout U )[n] id7671x2(U, size_t n)( shared(inout U )[n] ); |
| |
| void test7671() |
| { |
| static assert(is( typeof( id7671n1( (immutable(int)[3]).init ) ) == immutable(int[3]) )); |
| static assert(is( typeof( id7671x1( (immutable(int)[3]).init ) ) == immutable(int[3]) )); |
| |
| static assert(is( typeof( id7671n2( (immutable(int)[3]).init ) ) == immutable(int[3]) )); |
| static assert(is( typeof( id7671x2( (immutable(int)[3]).init ) ) == immutable(int[3]) )); |
| } |
| |
| /************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7672 |
| |
| T foo7672(T)(T a){ return a; } |
| |
| void test7672(inout(int[]) a = null, inout(int*) p = null) |
| { |
| static assert(is( typeof( a ) == inout(int[]) )); |
| static assert(is( typeof(foo7672(a)) == inout(int)[] )); |
| |
| static assert(is( typeof( p ) == inout(int*) )); |
| static assert(is( typeof(foo7672(p)) == inout(int)* )); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7684 |
| |
| U[] id7684(U)( U[] ); |
| shared(U[]) id7684(U)( shared(U[]) ); |
| |
| void test7684() |
| { |
| shared(int)[] x; |
| static assert(is( typeof(id7684(x)) == shared(int)[] )); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7694 |
| |
| void match7694(alias m)() |
| { |
| m.foo(); //removing this line suppresses ice in both cases |
| } |
| |
| struct T7694 |
| { |
| void foo(){} |
| void bootstrap() |
| { |
| //next line causes ice |
| match7694!(this)(); |
| //while this works: |
| alias this p; |
| match7694!(p)(); |
| } |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7755 |
| |
| template to7755(T) |
| { |
| T to7755(A...)(A args) |
| { |
| return toImpl7755!T(args); |
| } |
| } |
| |
| T toImpl7755(T, S)(S value) |
| { |
| return T.init; |
| } |
| |
| template Foo7755(T){} |
| |
| struct Bar7755 |
| { |
| void qux() |
| { |
| if (is(typeof(to7755!string(Foo7755!int)))){} |
| } |
| } |
| |
| /**********************************/ |
| |
| U[] id11a(U)( U[] ); |
| inout(U)[] id11a(U)( inout(U)[] ); |
| inout(U[]) id11a(U)( inout(U[]) ); |
| inout(shared(U[])) id11a(U)( inout(shared(U[])) ); |
| |
| void test11a(inout int _ = 0) |
| { |
| shared(const(int))[] x; |
| static assert(is( typeof(id11a(x)) == shared(const(int))[] )); |
| |
| shared(int)[] y; |
| static assert(is( typeof(id11a(y)) == shared(int)[] )); |
| |
| inout(U)[n] idz(U, size_t n)( inout(U)[n] ); |
| |
| inout(shared(bool[1])) z; |
| static assert(is( typeof(idz(z)) == inout(shared(bool[1])) )); |
| } |
| |
| inout(U[]) id11b(U)( inout(U[]) ); |
| |
| void test11b() |
| { |
| alias const(shared(int)[]) T; |
| static assert(is(typeof(id11b(T.init)) == const(shared(int)[]))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7769 |
| |
| void f7769(K)(inout(K) value){} |
| void test7769() |
| { |
| f7769("abc"); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7812 |
| |
| template A7812(T...) {} |
| |
| template B7812(alias C) if (C) {} |
| |
| template D7812() |
| { |
| alias B7812!(A7812!(NonExistent!())) D7812; |
| } |
| |
| static assert(!__traits(compiles, D7812!())); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7873 |
| |
| inout(T)* foo(T)(inout(T)* t) |
| { |
| static assert(is(T == int*)); |
| return t; |
| } |
| |
| inout(T)* bar(T)(inout(T)* t) |
| { |
| return foo(t); |
| } |
| |
| void test7873() |
| { |
| int *i; |
| bar(&i); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=7933 |
| |
| struct Boo7933(size_t dim){int a;} |
| struct Baa7933(size_t dim) |
| { |
| Boo7933!dim a; |
| //Boo7933!1 a; //(1) This version causes no errors |
| } |
| |
| auto foo7933()(Boo7933!1 b){return b;} |
| //auto fuu7933(Boo7933!1 b){return b;} //(2) This line neutralizes the error |
| |
| void test7933() |
| { |
| Baa7933!1 a; //(3) This line causes the error message |
| auto b = foo7933(Boo7933!1(1)); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8094 |
| |
| struct Tuple8094(T...) {} |
| |
| template getParameters8094(T, alias P) |
| { |
| static if (is(T t == P!U, U...)) |
| alias U getParameters8094; |
| else |
| static assert(false); |
| } |
| |
| void test8094() |
| { |
| alias getParameters8094!(Tuple8094!(int, string), Tuple8094) args; |
| } |
| |
| /**********************************/ |
| |
| struct Tuple12(T...) |
| { |
| void foo(alias P)() |
| { |
| alias Tuple12 X; |
| static if (is(typeof(this) t == X!U, U...)) |
| alias U getParameters; |
| else |
| static assert(false); |
| } |
| } |
| |
| void test12() |
| { |
| Tuple12!(int, string) t; |
| t.foo!Tuple12(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14290 |
| |
| struct Foo14290(int i) {} |
| alias Foo14290a = Foo14290!1; |
| static assert(!is(Foo14290!2 == Foo14290a!T, T...)); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8125 |
| |
| void foo8125(){} |
| |
| struct X8125(alias a) {} |
| |
| template Y8125a(T : A!f, alias A, alias f) {} //OK |
| template Y8125b(T : A!foo8125, alias A) {} //NG |
| |
| void test8125() |
| { |
| alias Y8125a!(X8125!foo8125) y1; |
| alias Y8125b!(X8125!foo8125) y2; |
| } |
| |
| /**********************************/ |
| |
| struct A13() {} |
| struct B13(TT...) {} |
| struct C13(T1) {} |
| struct D13(T1, TT...) {} |
| struct E13(T1, T2) {} |
| struct F13(T1, T2, TT...) {} |
| |
| template Test13(alias X) |
| { |
| static if (is(X x : P!U, alias P, U...)) |
| enum Test13 = true; |
| else |
| enum Test13 = false; |
| } |
| |
| void test13() |
| { |
| static assert(Test13!( A13!() )); |
| static assert(Test13!( B13!(int) )); |
| static assert(Test13!( B13!(int, double) )); |
| static assert(Test13!( B13!(int, double, string) )); |
| static assert(Test13!( C13!(int) )); |
| static assert(Test13!( D13!(int) )); |
| static assert(Test13!( D13!(int, double) )); |
| static assert(Test13!( D13!(int, double, string) )); |
| static assert(Test13!( E13!(int, double) )); |
| static assert(Test13!( F13!(int, double) )); |
| static assert(Test13!( F13!(int, double, string) )); |
| static assert(Test13!( F13!(int, double, string, bool) )); |
| } |
| |
| /**********************************/ |
| |
| struct A14(T, U, int n = 1) |
| { |
| } |
| |
| template Test14(alias X) |
| { |
| static if (is(X x : P!U, alias P, U...)) |
| alias U Test14; |
| else |
| static assert(0); |
| } |
| |
| void test14() |
| { |
| alias A14!(int, double) Type; |
| alias Test14!Type Params; |
| static assert(Params.length == 3); |
| static assert(is(Params[0] == int)); |
| static assert(is(Params[1] == double)); |
| static assert( Params[2] == 1); |
| } |
| |
| /**********************************/ |
| // test for evaluateConstraint assertion |
| |
| bool canSearchInCodeUnits15(C)(dchar c) |
| if (is(C == char)) |
| { |
| return true; |
| } |
| |
| void test15() |
| { |
| int needle = 0; |
| auto b = canSearchInCodeUnits15!char(needle); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8129 |
| |
| class X8129 {} |
| class A8129 {} |
| class B8129 : A8129 {} |
| |
| int foo8129(T : A8129)(X8129 x) { return 1; } |
| int foo8129(T : A8129)(X8129 x, void function (T) block) { return 2; } |
| |
| int bar8129(T, R)(R range, T value) { return 1; } |
| |
| int baz8129(T, R)(R range, T value) { return 1; } |
| int baz8129(T, R)(R range, Undefined value) { return 2; } |
| |
| void test8129() |
| { |
| auto x = new X8129; |
| assert(x.foo8129!B8129() == 1); |
| assert(x.foo8129!B8129((a){}) == 2); |
| assert(foo8129!B8129(x) == 1); |
| assert(foo8129!B8129(x, (a){}) == 2); |
| assert(foo8129!B8129(x) == 1); |
| assert(foo8129!B8129(x, (B8129 b){}) == 2); |
| |
| ubyte[] buffer = [0, 1, 2]; |
| assert(bar8129!ushort(buffer, 915) == 1); |
| |
| // While deduction, parameter type 'Undefined' shows semantic error. |
| static assert(!__traits(compiles, { |
| baz8129!ushort(buffer, 915); |
| })); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8238 |
| |
| void test8238() |
| { |
| static struct S { template t(){ int t; } } |
| |
| S s1, s2; |
| assert(cast(void*)&s1 != cast(void*)&s2 ); |
| assert(cast(void*)&s1 != cast(void*)&s1.t!()); |
| assert(cast(void*)&s2 != cast(void*)&s2.t!()); |
| assert(cast(void*)&s1.t!() == cast(void*)&s2.t!()); |
| s1.t!() = 256; |
| assert(s2.t!() == 256); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8669 |
| |
| struct X8669 |
| { |
| void mfoo(this T)() |
| { |
| static assert(is(typeof(this) == T)); |
| } |
| void cfoo(this T)() const |
| { |
| static assert(is(typeof(this) == const(T))); |
| } |
| void sfoo(this T)() shared |
| { |
| static assert(is(typeof(this) == shared(T))); |
| } |
| void scfoo(this T)() shared const |
| { |
| static assert(is(typeof(this) == shared(const(T)))); |
| } |
| void ifoo(this T)() immutable |
| { |
| static assert(is(typeof(this) == immutable(T))); |
| } |
| } |
| |
| void test8669() |
| { |
| X8669 mx; |
| const X8669 cx; |
| immutable X8669 ix; |
| shared X8669 sx; |
| shared const X8669 scx; |
| |
| mx.mfoo(); |
| cx.mfoo(); |
| ix.mfoo(); |
| sx.mfoo(); |
| scx.mfoo(); |
| |
| mx.cfoo(); |
| cx.cfoo(); |
| ix.cfoo(); |
| sx.cfoo(); |
| scx.cfoo(); |
| |
| static assert(!is(typeof( mx.sfoo() ))); |
| static assert(!is(typeof( cx.sfoo() ))); |
| ix.sfoo(); |
| sx.sfoo(); |
| scx.sfoo(); |
| |
| static assert(!is(typeof( mx.scfoo() ))); |
| static assert(!is(typeof( cx.scfoo() ))); |
| ix.scfoo(); |
| sx.scfoo(); |
| scx.scfoo(); |
| |
| static assert(!is(typeof( mx.ifoo() ))); |
| static assert(!is(typeof( cx.ifoo() ))); |
| ix.ifoo(); |
| static assert(!is(typeof( sx.ifoo() ))); |
| static assert(!is(typeof( scx.ifoo() ))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8833 |
| |
| template TypeTuple8833(T...) { alias TypeTuple = T; } |
| |
| void func8833(alias arg)() { } |
| |
| void test8833() |
| { |
| int x, y; |
| |
| alias TypeTuple8833!( |
| func8833!(x), |
| func8833!(y), |
| ) Map; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8976 |
| |
| void f8976(ref int) { } |
| |
| void g8976()() |
| { |
| f8976(0); // line 5 |
| } |
| |
| |
| void h8976()() |
| { |
| g8976!()(); |
| } |
| |
| static assert( __traits(compiles, h8976!()() ) ); // causes error |
| static assert(is(typeof( h8976!()() ))); |
| |
| void test8976() |
| { |
| static assert( __traits(compiles, h8976!()() ) ); |
| static assert(is(typeof( h8976!()() ))); |
| } |
| |
| /****************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8940 |
| |
| const int n8940; // or `immutable` |
| static this() { n8940 = 3; } |
| |
| void f8940(T)(ref int val) |
| { |
| assert(val == 3); |
| ++val; |
| } |
| |
| static assert(!__traits(compiles, f8940!void(n8940))); // fails |
| void test8940() |
| { |
| assert(n8940 == 3); |
| static assert(!__traits(compiles, f8940!void(n8940))); |
| //assert(n8940 == 3); // may pass as compiler caches comparison result |
| //assert(n8940 != 4); // may pass but likely will fail |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=6969 |
| // https://issues.dlang.org/show_bug.cgi?id=8990 |
| |
| class A6969() { alias C6969!() C1; } |
| class B6969 { alias A6969!() A1; } |
| class C6969() : B6969 {} |
| |
| struct A8990(T) { T t; } |
| struct B8990(T) { A8990!T* a; } |
| struct C8990 { B8990!C8990* b; } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9018 |
| |
| template Inst9018(alias Template, T) |
| { |
| alias Template!T Inst; |
| } |
| |
| template Template9018(T) |
| { |
| enum Template9018 = T; |
| } |
| |
| static assert(!__traits(compiles, Inst9018!(Template9018, int))); // Assert passes |
| static assert(!__traits(compiles, Inst9018!(Template9018, int))); // Assert fails |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9022 |
| |
| class C9022 |
| { |
| struct X {} |
| |
| alias B = X; |
| } |
| class D9022 |
| { |
| struct X {} |
| } |
| |
| void test9022() |
| { |
| auto c = new C9022(); |
| auto d = new D9022(); |
| auto cx = C9022.X(); |
| auto dx = D9022.X(); |
| |
| void foo1(T)(T, T.X) { static assert(is(T == C9022)); } |
| void foo2(T)(T.X, T) { static assert(is(T == C9022)); } |
| foo1(c, cx); |
| foo2(cx, c); |
| |
| void hoo1(T)(T, T.B) { static assert(is(T == C9022)); } |
| void hoo2(T)(T.B, T) { static assert(is(T == C9022)); } |
| hoo1(c, cx); |
| hoo1(c, cx); |
| |
| void bar1(alias A)(A.C9022, A.D9022) { static assert(A.stringof == "module breaker"); } |
| void bar2(alias A)(A.D9022, A.C9022) { static assert(A.stringof == "module breaker"); } |
| bar1(c, d); |
| bar2(d, c); |
| |
| void var1(alias A)(A.C9022, A.D9022.X) { static assert(A.stringof == "module breaker"); } |
| void var2(alias A)(A.D9022.X, A.C9022) { static assert(A.stringof == "module breaker"); } |
| var1(c, dx); |
| var2(dx, c); |
| |
| void baz(T)(T.X t, T.X u) { } |
| static assert(!__traits(compiles, baz(cx, dx))); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9026 |
| |
| mixin template node9026() |
| { |
| static if (is(this == struct)) |
| alias typeof(this)* E; |
| else |
| alias typeof(this) E; |
| E prev, next; |
| } |
| |
| struct list9026(alias N) |
| { |
| N.E head; |
| N.E tail; |
| } |
| |
| class A9026 |
| { |
| mixin node9026 L1; |
| mixin node9026 L2; |
| } |
| |
| list9026!(A9026.L1) g9026_l1; |
| list9026!(A9026.L2) g9026_l2; |
| |
| void test9026() |
| { |
| list9026!(A9026.L1) l9026_l1; |
| list9026!(A9026.L2) l9026_l2; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9038 |
| |
| mixin template Foo9038() |
| { |
| string data = "default"; |
| } |
| |
| class Bar9038 |
| { |
| string data; |
| mixin Foo9038 f; |
| } |
| |
| void check_data9038(alias M, T)(T obj) |
| { |
| //writeln(M.stringof); |
| assert(obj.data == "Bar"); |
| assert(obj.f.data == "F"); |
| } |
| |
| void test9038() |
| { |
| auto bar = new Bar9038; |
| bar.data = "Bar"; |
| bar.f.data = "F"; |
| |
| assert(bar.data == "Bar"); |
| assert(bar.f.data == "F"); |
| |
| check_data9038!(Bar9038)(bar); |
| check_data9038!(Bar9038.f)(bar); |
| check_data9038!(bar.f)(bar); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9050 |
| |
| struct A9050(T) {} |
| |
| struct B9050(T) |
| { |
| void f() { foo9050(A9050!int()); } |
| } |
| |
| auto foo9050()(A9050!int base) pure |
| { |
| return B9050!int(); |
| } |
| |
| auto s9050 = foo9050(A9050!int()); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10936 (dup of 9050) |
| |
| struct Vec10936(string s) |
| { |
| auto foo(string v)() |
| { |
| return Vec10936!(v)(); |
| } |
| |
| static void bar() |
| { |
| Vec10936!"" v; |
| auto p = v.foo!"sup"; |
| } |
| } |
| |
| Vec10936!"" v; |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9076 |
| |
| template forward9076(args...) |
| { |
| @property forward9076()(){ return args[0]; } |
| } |
| |
| void test9076() |
| { |
| int a = 1; |
| int b = 1; |
| assert(a == forward9076!b); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9083 |
| |
| template isFunction9083(X...) if (X.length == 1) |
| { |
| enum isFunction9083 = true; |
| } |
| |
| struct S9083 |
| { |
| static string func(alias Class)() |
| { |
| foreach (m; __traits(allMembers, Class)) |
| { |
| pragma(msg, m); // prints "func" |
| enum x1 = isFunction9083!(mixin(m)); //NG |
| enum x2 = isFunction9083!(func); //OK |
| } |
| return ""; |
| } |
| } |
| enum nothing9083 = S9083.func!S9083(); |
| |
| class C9083 |
| { |
| int x; // some class members |
| |
| void func() |
| { |
| void templateFunc(T)(const T obj) |
| { |
| enum x1 = isFunction9083!(mixin("x")); // NG |
| enum x2 = isFunction9083!(x); // NG |
| } |
| templateFunc(this); |
| } |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9100 |
| |
| template Id(alias A) { alias Id = A; } |
| template ErrId(alias A) { static assert(0); } |
| template TypeTuple9100(TL...) { alias TypeTuple9100 = TL; } |
| |
| class C9100 |
| { |
| int value; |
| |
| int fun() { return value; } |
| int tfun(T)() { return value; } |
| TypeTuple9100!(int, long) field; |
| |
| void test() |
| { |
| this.value = 1; |
| auto c = new C9100(); |
| c.value = 2; |
| |
| alias t1a = Id!(c.fun); // OK |
| alias t1b = Id!(this.fun); // Prints weird error, bad |
| // -> internally given TOKdotvar |
| assert(t1a() == this.value); |
| assert(t1b() == this.value); |
| |
| alias t2a = Id!(c.tfun); // OK |
| static assert(!__traits(compiles, ErrId!(this.tfun))); |
| alias t2b = Id!(this.tfun); // No error occurs, why? |
| // -> internally given TOKdottd |
| assert(t2a!int() == this.value); |
| assert(t2b!int() == this.value); |
| |
| alias t3a = Id!(foo9100); // OK |
| alias t3b = Id!(mixin("foo9100")); // Prints weird error, bad |
| // -> internally given TOKtemplate |
| assert(t3a() == 10); |
| assert(t3b() == 10); |
| |
| assert(field[0] == 0); |
| alias t4a = TypeTuple9100!(field); // NG |
| alias t4b = TypeTuple9100!(GetField9100!()); // NG |
| t4a[0] = 1; assert(field[0] == 1); |
| t4b[0] = 2; assert(field[0] == 2); |
| } |
| } |
| |
| int foo9100()() { return 10; } |
| template GetField9100() { alias GetField9100 = C9100.field[0]; } |
| |
| void test9100() |
| { |
| (new C9100()).test(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9101 |
| |
| class Node9101 |
| { |
| template ForwardCtorNoId() |
| { |
| this() {} // default constructor |
| void foo() { 0 = 1; } // wrong code |
| } |
| } |
| enum x9101 = __traits(compiles, Node9101.ForwardCtorNoId!()); |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9124 |
| |
| struct Foo9124a(N...) |
| { |
| enum SIZE = N[0]; |
| private int _val; |
| |
| public void opAssign (T) (T other) |
| if (is(T unused == Foo9124a!(_N), _N...)) |
| { |
| _val = other._val; // compile error |
| this._val = other._val; // explicit this make it work |
| } |
| |
| public auto opUnary (string op) () if (op == "~") { |
| Foo9124a!(SIZE) result = this; |
| return result; |
| } |
| } |
| void test9124a() |
| { |
| Foo9124a!(28) a; |
| Foo9124a!(28) b = ~a; |
| } |
| |
| // -------- |
| |
| template Foo9124b(T, U, string OP) |
| { |
| enum N = T.SIZE; |
| alias Foo9124b = Foo9124b!(false, true, N); |
| } |
| struct Foo9124b(bool S, bool L, N...) |
| { |
| enum SIZE = 5; |
| long[1] _a = 0; |
| void someFunction() const { |
| auto data1 = _a; // Does not compile |
| auto data2 = this._a; // <--- Compiles |
| } |
| auto opBinary(string op, T)(T) { |
| Foo9124b!(typeof(this), T, op) test; |
| } |
| } |
| void test9124b() |
| { |
| auto p = Foo9124b!(false, false, 5)(); |
| auto q = Foo9124b!(false, false, 5)(); |
| p|q; |
| p&q; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9143 |
| |
| struct Foo9143a(bool S, bool L) |
| { |
| auto noCall() { |
| Foo9143a!(S, false) x1; // compiles if this line commented |
| static if(S) Foo9143a!(true, false) x2; |
| else Foo9143a!(false, false) x2; |
| } |
| this(T)(T other) // constructor |
| if (is(T unused == Foo9143a!(P, Q), bool P, bool Q)) { } |
| } |
| |
| struct Foo9143b(bool L, size_t N) |
| { |
| void baaz0() { |
| bar!(Foo9143b!(false, N))(); // line 7 |
| // -> move to before the baaz semantic |
| } |
| void baaz() { |
| bar!(Foo9143b!(false, 2LU))(); // line 3 |
| bar!(Foo9143b!(true, 2LU))(); // line 4 |
| bar!(Foo9143b!(L, N))(); // line 5 |
| bar!(Foo9143b!(true, N))(); // line 6 |
| bar!(Foo9143b!(false, N))(); // line 7 |
| } |
| void bar(T)() |
| if (is(T unused == Foo9143b!(_L, _N), bool _L, size_t _N)) |
| {} |
| } |
| |
| void test9143() |
| { |
| Foo9143a!(false, true) k = Foo9143a!(false, false)(); |
| |
| auto p = Foo9143b!(true, 2LU)(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9266 |
| |
| template Foo9266(T...) |
| { |
| T Foo9266; |
| } |
| struct Bar9266() |
| { |
| alias Foo9266!int f; |
| } |
| void test9266() |
| { |
| Bar9266!() a, b; |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9361 |
| |
| struct Unit9361(A) |
| { |
| void butPleaseDontUseMe()() |
| if (is(unitType9361!((this)))) // ! |
| {} |
| |
| } |
| template isUnit9361(alias T) if ( is(T)) {} |
| template isUnit9361(alias T) if (!is(T)) {} |
| |
| template unitType9361(alias T) if (isUnit9361!T) {} |
| |
| void test9361() |
| { |
| Unit9361!int u; |
| static assert(!__traits(compiles, u.butPleaseDontUseMe())); // crashes |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9536 |
| |
| struct S9536 |
| { |
| static A foo(A)(A a) |
| { |
| return a * 2; |
| } |
| int bar() const |
| { |
| return foo(42); |
| } |
| } |
| |
| void test9536() |
| { |
| S9536 s; |
| assert(s.bar() == 84); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9578 |
| |
| template t9578(alias f) { void tf()() { f(); } } |
| |
| void g9578a(alias f)() { f(); } // Error -> OK |
| void g9578b(alias ti)() { ti.tf(); } // Error -> OK |
| |
| void test9578() |
| { |
| int i = 0; |
| int m() { return i; } |
| |
| g9578a!(t9578!m.tf)(); |
| g9578b!(t9578!m)(); |
| } |
| |
| /**********************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9596 |
| |
| int foo9596a(K, V)(inout( V [K])) { return 1; } |
| int foo9596a(K, V)(inout(shared(V) [K])) { return 2; } |
| |
| int foo9596b(K, V)(inout( V [K])) { return 1; } |
| int foo9596b(K, V)(inout( const(V) [K])) { return 3; } |
| |
| int foo9596c(K, V)(inout(shared(V) [K])) { return 2; } |
| int foo9596c(K, V)(inout( const(V) [K])) { return 3; } |
| |
| int foo9596d(K, V)(inout( V [K])) { return 1; } |
| int foo9596d(K, V)(inout(shared(V) [K])) { return 2; } |
| int foo9596d(K, V)(inout( const(V) [K])) { return 3; } |
| |
| int foo9596e(K, V)(inout(shared(V) [K])) { return 2; } |
| int foo9596e(K, V)(inout( V [K])) { return 1; } |
| int foo9596e(K, V)(inout( const(V) [K])) { return 3; } |
| |
| void test9596() |
| { |
| shared(int)[int] aa; |
| static assert(!__traits(compiles, foo9596a(aa))); |
| |
| assert(foo9596b(aa) == 1); |
| assert(foo9596c(aa) == 2); |
| |
| static assert(!__traits(compiles, foo9596d(aa))); |
| static assert(!__traits(compiles, foo9596e(aa))); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9806 |
| |
| struct S9806a(alias x) |
| { |
| alias S9806a!0 N; |
| } |
| enum expr9806a = 0 * 0; |
| alias S9806a!expr9806a T9806a; |
| |
| // -------- |
| |
| struct S9806b(alias x) |
| { |
| template Next() |
| { |
| enum expr = x + 1; |
| alias S9806b!expr Next; |
| } |
| } |
| alias S9806b!1 One9806b; |
| alias S9806b!0.Next!() OneAgain9806b; |
| |
| // -------- |
| |
| struct S9806c(x...) |
| { |
| template Next() |
| { |
| enum expr = x[0] + 1; |
| alias S9806c!expr Next; |
| } |
| } |
| alias S9806c!1 One9806c; |
| alias S9806c!0.Next!() OneAgain9806c; |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9837 |
| |
| void test9837() |
| { |
| enum DA : int[] { a = [1,2,3] } |
| DA da; |
| int[] bda = da; |
| static assert(is(DA : int[])); |
| void fda1(int[] a) {} |
| void fda2(T)(T[] a) {} |
| fda1(da); |
| fda2(da); |
| |
| enum SA : int[3] { a = [1,2,3] } |
| SA sa; |
| int[3] bsa = sa; |
| static assert(is(SA : int[3])); |
| void fsa1(int[3] a) {} |
| void fsa2(T)(T[3] a) {} |
| void fsa3(size_t d)(int[d] a) {} |
| void fsa4(T, size_t d)(T[d] a) {} |
| fsa1(sa); |
| fsa2(sa); |
| fsa3(sa); |
| fsa4(sa); |
| |
| enum AA : int[int] { a = null } |
| AA aa; |
| int[int] baa = aa; |
| static assert(is(AA : int[int])); |
| void faa1(int[int] a) {} |
| void faa2(V)(V[int] a) {} |
| void faa3(K)(int[K] a) {} |
| void faa4(K, V)(V[K] a) {} |
| faa1(aa); |
| faa2(aa); |
| faa3(aa); |
| faa4(aa); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9874 |
| |
| bool foo9874() { return true; } |
| void bar9874(T)(T) if (foo9874()) {} // OK |
| void baz9874(T)(T) if (foo9874) {} // error |
| |
| void test9874() |
| { |
| foo9874; // OK |
| bar9874(0); |
| baz9874(0); |
| } |
| |
| /******************************************/ |
| |
| void test9885() |
| { |
| void foo(int[1][]) {} |
| void boo()(int[1][]){} |
| struct X(T...) { static void xoo(T){} } |
| struct Y(T...) { static void yoo()(T){} } |
| struct Z(T...) { static void zoo(U...)(T, U){} } |
| |
| struct V(T...) { static void voo()(T, ...){} } |
| struct W(T...) { static void woo()(T...){} } |
| |
| struct R(T...) { static void roo(U...)(int, U, T){} } |
| |
| // OK |
| foo([[10]]); |
| boo([[10]]); |
| |
| // OK |
| X!(int[1][]).xoo([[10]]); |
| |
| // NG! |
| Y!().yoo(); |
| Y!(int).yoo(1); |
| Y!(int, int[]).yoo(1, [10]); |
| static assert(!__traits(compiles, Y!().yoo(1))); |
| static assert(!__traits(compiles, Y!(int).yoo("a"))); |
| static assert(!__traits(compiles, Y!().yoo!(int)())); |
| |
| // NG! |
| Z!().zoo(); |
| Z!().zoo([1], [1:1]); |
| Z!(int, string).zoo(1, "a"); |
| Z!(int, string).zoo(1, "a", [1], [1:1]); |
| Z!().zoo!()(); |
| static assert(!__traits(compiles, Z!().zoo!()(1))); // (none) <- 1 |
| static assert(!__traits(compiles, Z!(int).zoo!()())); // int <- (none) |
| static assert(!__traits(compiles, Z!(int).zoo!()(""))); // int <- "" |
| static assert(!__traits(compiles, Z!().zoo!(int)())); // int <- (none) |
| static assert(!__traits(compiles, Z!().zoo!(int)(""))); // int <- "" |
| |
| V!().voo(1,2,3); |
| V!(int).voo(1,2,3); |
| V!(int, long).voo(1,2,3); |
| static assert(!__traits(compiles, V!(int).voo())); // int <- (none) |
| static assert(!__traits(compiles, V!(int, long).voo(1))); // long <- (none) |
| static assert(!__traits(compiles, V!(int, string).voo(1,2,3))); // string <- 2 |
| |
| W!().woo(); |
| //W!().woo(1, 2, 3); // Access Violation |
| { // this behavior is consistent with: |
| //alias TL = TypeTuple!(); |
| //void foo(TL...) {} |
| //foo(1, 2, 3); // Access Violation |
| //pragma(msg, typeof(foo)); // void(...) -> D-style variadic function? |
| } |
| W!(int,int[]).woo(1,2,3); |
| W!(int,int[2]).woo(1,2,3); |
| static assert(!__traits(compiles, W!(int,int,int).woo(1,2,3))); // int... <- 2 |
| static assert(!__traits(compiles, W!(int,int).woo(1,2))); // int... <- 2 |
| static assert(!__traits(compiles, W!(int,int[2]).woo(1,2))); // int[2]... <- 2 |
| |
| R!().roo(1, "", []); |
| R!(int).roo(1, "", [], 1); |
| R!(int, string).roo(1, "", [], 1, ""); |
| R!(int, string).roo(1, 2, ""); |
| static assert(!__traits(compiles, R!(int).roo(1, "", []))); // int <- [] |
| static assert(!__traits(compiles, R!(int, int).roo(1, "", []))); // int <- [] |
| static assert(!__traits(compiles, R!(int, string).roo(1, 2, 3))); // string <- 3 |
| |
| // test case |
| struct Tuple(T...) { this()(T values) {} } |
| alias T = Tuple!(int[1][]); |
| auto t = T([[10]]); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9971 |
| |
| void goo9971()() |
| { |
| auto g = &goo9971; |
| } |
| |
| struct S9971 |
| { |
| void goo()() |
| { |
| auto g = &goo; |
| static assert(is(typeof(g) == delegate)); |
| } |
| } |
| |
| void test9971() |
| { |
| goo9971!()(); |
| |
| S9971.init.goo!()(); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9977 |
| |
| void test9977() |
| { |
| struct S1(T) { T value; } |
| auto func1(T)(T value) { return value; } |
| static assert(is(S1!int == struct)); |
| assert(func1(10) == 10); |
| |
| template S2(T) { struct S2 { T value; } } |
| template func2(T) { auto func2(T value) { return value; } } |
| static assert(is(S2!int == struct)); |
| assert(func2(10) == 10); |
| |
| template X(T) { alias X = T[3]; } |
| static assert(is(X!int == int[3])); |
| |
| int a; |
| template Y(T) { alias Y = T[typeof(a)]; } |
| static assert(is(Y!double == double[int])); |
| |
| int v = 10; |
| template Z() { alias Z = v; } |
| assert(v == 10); |
| Z!() = 20; |
| assert(v == 20); |
| } |
| |
| /******************************************/ |
| |
| enum T8848a(int[] a) = a; |
| enum T8848b(int[int] b) = b; |
| enum T8848c(void* c) = c; |
| |
| static assert(T8848a!([1,2,3]) == [1,2,3]); |
| static assert(T8848b!([1:2,3:4]) == [1:2,3:4]); |
| static assert(T8848c!(null) == null); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9990 |
| |
| auto initS9990() { return "hi"; } |
| |
| class C9990(alias init) {} |
| |
| alias SC9990 = C9990!(initS9990); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10067 |
| |
| struct assumeSize10067(alias F) {} |
| |
| template useItemAt10067(size_t idx, T) |
| { |
| void impl(){ } |
| |
| alias useItemAt10067 = assumeSize10067!(impl); |
| } |
| |
| useItemAt10067!(0, char) mapS10067; |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=4072 |
| |
| void bug4072(T)(T x) |
| if (is(typeof(bug4072(x)))) |
| {} |
| |
| static assert(!is(typeof(bug4072(7)))); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10074 |
| |
| template foo10074(F) |
| { |
| enum foo10074 = false; |
| } |
| bool foo10074(F)(F f) |
| if (foo10074!F) |
| { |
| return false; |
| } |
| |
| static assert(!is(typeof(foo10074(1)))); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10083 |
| |
| // [a-c] IFTI can find syntactic eponymous member |
| template foo10083a(T) |
| { |
| int foo10083a(double) { return 1; } |
| int foo10083a(T) { return 2; } |
| } |
| template foo10083b(T) |
| { |
| int foo10083b(T) { return 1; } |
| int foo10083b(T, T) { return 2; } |
| } |
| template foo10083c1(T) |
| { |
| int foo10083c1(T) { return 1; } |
| static if (true) { int x; } |
| } |
| template foo10083c2(T) |
| { |
| int foo10083c2(T) { return 1; } |
| static if (true) { int x; } else { int y; } |
| } |
| |
| // [d-f] IFTI cannot find syntactic eponymous member |
| template foo10083d1(T) |
| { |
| static if (true) |
| { |
| int foo10083d1(T) { return 1; } |
| } |
| else |
| { |
| } |
| } |
| template foo10083d2(T) |
| { |
| static if (true) |
| { |
| } |
| else |
| { |
| int foo10083d2(T) { return 1; } |
| } |
| } |
| template foo10083e(T) |
| { |
| static if (true) |
| { |
| int foo10083e(double arg) { return 1; } |
| } |
| int foo10083e(T arg) { return 2; } |
| } |
| template foo10083f(T) |
| { |
| static if (true) |
| { |
| int foo10083f(T) { return 1; } |
| } |
| else |
| { |
| int foo10083f(T) { return 2; } |
| } |
| } |
| |
| void test10083() |
| { |
| assert(foo10083a(1) == 2); |
| assert(foo10083a!int(1) == 2); |
| assert(foo10083a!int(1.0) == 1); |
| static assert(!__traits(compiles, foo10083a!double(1))); |
| static assert(!__traits(compiles, foo10083a!double(1.0))); |
| static assert(!__traits(compiles, foo10083a!real(1))); |
| assert(foo10083a!real(1.0) == 1); |
| assert(foo10083a!real(1.0L) == 2); |
| |
| assert(foo10083b(2) == 1); |
| assert(foo10083b(3, 4) == 2); |
| static assert(!__traits(compiles, foo10083b(2, ""))); |
| |
| assert(foo10083c1(1) == 1); |
| assert(foo10083c2(1) == 1); |
| |
| static assert(!__traits(compiles, foo10083d1(2))); |
| static assert(!__traits(compiles, foo10083d2(2))); |
| static assert(!__traits(compiles, foo10083e(3))); |
| static assert(!__traits(compiles, foo10083f(3))); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10134 |
| |
| template ReturnType10134(alias func) |
| { |
| static if (is(typeof(func) R == return)) |
| alias R ReturnType10134; |
| else |
| static assert(0); |
| } |
| |
| struct Result10134(T) {} |
| |
| template getResultType10134(alias func) |
| { |
| static if(is(ReturnType10134!(func.exec) _ == Result10134!(T), T)) |
| { |
| alias getResultType10134 = T; |
| } |
| } |
| |
| template f10134(alias func) |
| { |
| Result10134!(getResultType10134!(func)) exec(int i) |
| { |
| return typeof(return)(); |
| } |
| } |
| |
| template a10134() |
| { |
| Result10134!(double) exec(int i) |
| { |
| return b10134!().exec(i); |
| } |
| } |
| |
| template b10134() |
| { |
| Result10134!(double) exec(int i) |
| { |
| return f10134!(a10134!()).exec(i); |
| } |
| } |
| |
| pragma(msg, getResultType10134!(a10134!())); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10313 |
| |
| void test10313() |
| { |
| struct Nullable(T) |
| { |
| this()(inout T value) inout {} |
| } |
| |
| struct S { S[] array; } |
| S s; |
| auto ns = Nullable!S(s); |
| |
| class C { C[] array; } |
| C c; |
| auto nc = Nullable!C(c); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10498 |
| |
| template triggerIssue10498a() |
| { |
| enum triggerIssue10498a = __traits(compiles, { T10498a; }); |
| } |
| |
| template PackedGenericTuple10498a(Args...) |
| { |
| alias Args Tuple; |
| enum e = triggerIssue10498a!(); |
| } |
| |
| struct S10498a { } |
| |
| template T10498a() |
| { |
| alias PackedGenericTuple10498a!S10498a T10498a; |
| } |
| |
| void test10498a() |
| { |
| alias T10498a!() t; |
| static assert(is(t.Tuple[0])); // Fails -> OK |
| } |
| |
| // -------- |
| |
| template triggerIssue10498b(A...) |
| { |
| enum triggerIssue10498b = __traits(compiles, { auto a = A[0]; }); |
| } |
| |
| template PackedGenericTuple10498b(Args...) |
| { |
| alias Args Tuple; |
| enum e = triggerIssue10498b!Args; |
| } |
| |
| template T10498b() |
| { |
| struct S {} // The fact `S` is in `T` causes the problem |
| alias PackedGenericTuple10498b!S T10498b; |
| } |
| |
| void test10498b() |
| { |
| alias T10498b!() t; |
| static assert(is(t.Tuple[0])); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10537 |
| |
| struct Iota10537 |
| { |
| int s,e,i; |
| mixin Yield10537!q{ ; }; |
| } |
| |
| auto skipStrings10537(T)(T source) |
| { |
| return ""; |
| } |
| |
| mixin template Yield10537(dstring code) |
| { |
| alias X = typeof({ enum x = rewriteCode10537(code); }()); |
| } |
| |
| dstring rewriteCode10537(dstring code) |
| { |
| skipStrings10537(code); // IFTI causes forward reference |
| return ""; |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10558 |
| |
| template Template10558() {} |
| |
| struct Struct10558(alias T){} |
| |
| alias bar10558 = foo10558!(Template10558!()); |
| |
| template foo10558(alias T) |
| { |
| alias foobar = Struct10558!T; |
| |
| void fun() |
| { |
| alias a = foo10558!T; |
| } |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10592 |
| |
| void test10592() |
| { |
| struct A(E) |
| { |
| int put()(const(E)[] data) |
| { |
| return 1; |
| } |
| |
| int put()(const(dchar)[] data) if (!is(E == dchar)) |
| { |
| return 2; |
| } |
| |
| int put(C)(const(C)[] data) if (!is(C == dchar) && !is(E == C)) |
| { |
| return 3; |
| } |
| } |
| |
| A!char x; |
| assert(x.put("abcde"c) == 1); // OK: hit 1 |
| assert(x.put("abcde"w) == 3); // NG: this should hit 3 |
| assert(x.put("abcde"d) == 2); // OK: hit 2 |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11242 |
| |
| inout(T[]) fromString11242(T)(inout(char[]) s, T[] dst) |
| { |
| return s; |
| } |
| |
| void test11242() |
| { |
| char[] a; |
| fromString11242(a, a); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10811 |
| |
| void foo10811a(R1, R2)(R1, R2) {} |
| template foo10811a(alias pred) { void foo10811a(R1, R2)(R1, R2) {} } |
| |
| template foo10811b(alias pred) { void foo10811b(R1, R2)(R1, R2) {} } |
| void foo10811b(R1, R2)(R1, R2) {} |
| |
| void test10811() |
| { |
| foo10811a(1, 2); |
| foo10811a!(a => a)(1, 2); |
| |
| foo10811b(1, 2); |
| foo10811b!(a => a)(1, 2); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=10969 |
| |
| template A10969(T, U...) { alias A10969 = T; } |
| void foo10969(T, U...)(A10969!(T, U) a) {} |
| |
| template B10969(T, U) { alias B10969 = T; } |
| void bar10969(T, U...)(B10969!(T, U[0]) a) {} |
| |
| void test10969() |
| { |
| foo10969!(int, float)(3); |
| bar10969!(int, float)(3); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11271 |
| |
| struct SmartPtr11271(T) |
| { |
| ~this() {} |
| void opAssign(U)(auto ref U rh) {} |
| } |
| |
| void test11271() |
| { |
| SmartPtr11271!Object a; |
| a = SmartPtr11271!Object(); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11533 |
| |
| version (none) |
| { |
| struct S11533 |
| { |
| void put(alias fun)() { fun!int(); } |
| } |
| void test11533a() |
| { |
| static void foo(T)() {} |
| S11533 s; |
| s.put!foo(); |
| } |
| |
| void test11533b() |
| { |
| static void bar(alias fun)() { fun(); } |
| void nested() {} |
| bar!nested(); |
| } |
| |
| void test11533c() |
| { |
| static struct Foo(alias fun) |
| { |
| auto call() { return fun(); } |
| } |
| int var = 1; |
| auto getVar() { return var; } |
| Foo!getVar foo; |
| assert(foo.call() == var); |
| var += 1; |
| assert(foo.call() == var); |
| } |
| |
| void test11533() |
| { |
| test11533a(); |
| test11533b(); |
| test11533c(); |
| } |
| } |
| else |
| { |
| void test11533() |
| { |
| } |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11553 |
| |
| struct Pack11553(T ...) |
| { |
| alias Unpack = T; |
| enum length = T.length; |
| } |
| |
| template isPack11553(TList ...) |
| { |
| static if (TList.length == 1 && is(Pack11553!(TList[0].Unpack) == TList[0])) |
| { |
| enum isPack11553 = true; |
| } |
| else |
| { |
| enum isPack11553 = false; |
| } |
| } |
| |
| template PartialApply11553(alias T, uint argLoc, Arg ...) |
| if (Arg.length == 1) |
| { |
| template PartialApply11553(L ...) |
| { |
| alias PartialApply11553 = T!(L[0 .. argLoc], Arg, L[argLoc .. $]); |
| } |
| } |
| |
| template _hasLength11553(size_t len, T) |
| { |
| static if (T.length == len) |
| { |
| enum _hasLength11553 = true; |
| } |
| else |
| { |
| enum _hasLength11553 = false; |
| } |
| } |
| |
| alias _hasLength11553(size_t len) = PartialApply11553!(._hasLength11553, 0, len); |
| |
| |
| alias hl11553 = _hasLength11553!1; |
| |
| // this segfaults |
| static if (!isPack11553!hl11553) { pragma(msg, "All good 1"); } |
| |
| // these are fine |
| static if ( hl11553!(Pack11553!(5))) { pragma(msg, "All good 2"); } |
| |
| static if (!hl11553!(Pack11553!( ))) { pragma(msg, "All good 3"); } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11818 |
| |
| enum E11818 { e0, e1 } |
| |
| struct SortedRange11818 |
| { |
| void fun(E11818 e = true ? E11818.e0 : E11818.e1)() |
| { |
| } |
| } |
| |
| void test11818() |
| { |
| SortedRange11818 s; |
| s.fun(); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11843 |
| |
| void test11843() |
| { |
| struct Foo |
| { |
| int[string] x; |
| } |
| |
| struct Bar(alias foo) {} |
| |
| enum bar1 = Bar!(Foo(["a": 1]))(); |
| enum bar2 = Bar!(Foo(["a": 1]))(); |
| static assert(is(typeof(bar1) == typeof(bar2))); |
| |
| enum foo1 = Foo(["a": 1]); |
| enum foo2 = Foo(["b": -1]); |
| static assert(!__traits(isSame, foo1, foo2)); |
| enum bar3 = Bar!foo1(); |
| enum bar4 = Bar!foo2(); |
| static assert(!is(typeof(bar3) == typeof(bar4))); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=11872 |
| |
| class Foo11872 |
| { |
| auto test(int v)() {} |
| auto test(int v)(string) {} |
| |
| template Bar(T) |
| { |
| void test(T) {} |
| } |
| } |
| |
| void test11872() |
| { |
| auto foo = new Foo11872(); |
| |
| with (foo) |
| { |
| // ScopeExp(ti) -> DotTemplateInstanceExp(wthis, ti) |
| foo.test!2(); // works |
| test!2(); // works <- fails |
| test!2; // works <- fails |
| |
| // ScopeExp(ti) -> DotTemplateInstanceExp(wthis, ti) -> DotExp(wthis, ScopeExp) |
| foo.Bar!int.test(1); // works |
| Bar!int.test(1); // works <- fails |
| } |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12042 |
| |
| struct S12042 |
| { |
| int[] t; |
| |
| void m()() |
| { |
| t = null; // CTFE error -> OK |
| } |
| } |
| |
| int test12042() |
| { |
| S12042 s; |
| |
| with (s) |
| m!()(); |
| |
| return 1; |
| } |
| |
| static assert(test12042()); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12077 |
| |
| struct S12077(A) {} |
| |
| alias T12077(alias T : Base!Args, alias Base, Args...) = Base; |
| static assert(__traits(isSame, T12077!(S12077!int), S12077)); |
| |
| alias U12077(alias T : Base!Args, alias Base, Args...) = Base; |
| alias U12077( T : Base!Args, alias Base, Args...) = Base; |
| static assert(__traits(isSame, U12077!(S12077!int), S12077)); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12262 |
| |
| template Inst12262(T) { int x; } |
| |
| enum fqnSym12262(alias a) = 1; |
| enum fqnSym12262(alias a : B!A, alias B, A...) = 2; |
| |
| static assert(fqnSym12262!(Inst12262!(Object)) == 2); |
| static assert(fqnSym12262!(Inst12262!(Object).x) == 1); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12264 |
| |
| struct S12264(A) {} |
| |
| template AX12264(alias A1) { enum AX12264 = 1; } |
| template AX12264(alias A2 : B!A, alias B, A...) { enum AX12264 = 2; } |
| template AY12264(alias A1) { enum AY12264 = 1; } |
| template AY12264(alias A2 : B!int, alias B) { enum AY12264 = 2; } |
| template AZ12264(alias A1) { enum AZ12264 = 1; } |
| template AZ12264(alias A2 : S12264!T, T) { enum AZ12264 = 2; } |
| static assert(AX12264!(S12264!int) == 2); |
| static assert(AY12264!(S12264!int) == 2); |
| static assert(AZ12264!(S12264!int) == 2); |
| |
| template TX12264(T1) { enum TX12264 = 1; } |
| template TX12264(T2 : B!A, alias B, A...) { enum TX12264 = 2; } |
| template TY12264(T1) { enum TY12264 = 1; } |
| template TY12264(T2 : B!int, alias B) { enum TY12264 = 2; } |
| template TZ12264(T1) { enum TZ12264 = 1; } |
| template TZ12264(T2 : S12264!T, T) { enum TZ12264 = 2; } |
| static assert(TX12264!(S12264!int) == 2); |
| static assert(TY12264!(S12264!int) == 2); |
| static assert(TZ12264!(S12264!int) == 2); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12122 |
| |
| enum N12122 = 1; |
| |
| void foo12122(T)(T[N12122]) if(is(T == int)) {} |
| |
| void test12122() |
| { |
| int[N12122] data; |
| foo12122(data); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12186 |
| |
| template map_front12186(fun...) |
| { |
| auto map_front12186(Range)(Range r) |
| { |
| return fun[0](r[0]); |
| } |
| } |
| |
| void test12186() |
| { |
| immutable int[][] mat; |
| |
| mat.map_front12186!((in r) => 0); // OK |
| mat.map_front12186!((const r) => 0); // OK |
| mat.map_front12186!((immutable int[] r) => 0); // OK |
| mat.map_front12186!((immutable r) => 0); // OK <- Error |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12207 |
| |
| void test12207() |
| { |
| static struct S |
| { |
| static void f(T)(T) {} |
| } |
| |
| immutable S s; |
| |
| s.f(1); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12263 |
| |
| template A12263(alias a) { int x; } |
| template B12263(alias a) { int x; } |
| |
| template fqnSym12263(alias T : B12263!A, alias B12263, A...) |
| { |
| enum fqnSym12263 = true; |
| } |
| |
| static assert(fqnSym12263!(A12263!(Object))); |
| static assert(fqnSym12263!(B12263!(Object))); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12290 |
| |
| void test12290() |
| { |
| short[] arrS; |
| float[] arrF; |
| double[] arrD; |
| real[] arrR; |
| string cstr; |
| wstring wstr; |
| dstring dstr; |
| short[short] aa; |
| |
| auto func1a(E)(E[], E) { return E.init; } |
| auto func1b(E)(E, E[]) { return E.init; } |
| |
| static assert(is(typeof(func1a(arrS, 1)) == short)); |
| static assert(is(typeof(func1b(1, arrS)) == short)); |
| static assert(is(typeof(func1a(arrF, 1.0)) == float)); |
| static assert(is(typeof(func1b(1.0, arrF)) == float)); |
| static assert(is(typeof(func1a(arrD, 1.0L)) == double)); |
| static assert(is(typeof(func1b(1.0L, arrD)) == double)); |
| static assert(is(typeof(func1a(arrR, 1)) == real)); |
| static assert(is(typeof(func1b(1, arrR)) == real)); |
| static assert(is(typeof(func1a("str" , 'a')) == immutable char)); |
| static assert(is(typeof(func1b('a', "str" )) == immutable char)); |
| static assert(is(typeof(func1a("str"c, 'a')) == immutable char)); |
| static assert(is(typeof(func1b('a', "str"c)) == immutable char)); |
| static assert(is(typeof(func1a("str"w, 'a')) == immutable wchar)); |
| static assert(is(typeof(func1b('a', "str"w)) == immutable wchar)); |
| static assert(is(typeof(func1a("str"d, 'a')) == immutable dchar)); |
| static assert(is(typeof(func1b('a', "str"d)) == immutable dchar)); |
| static assert(is(typeof(func1a([1,2,3], 1L)) == long)); |
| static assert(is(typeof(func1b(1L, [1,2,3])) == long)); |
| static assert(is(typeof(func1a([1,2,3], 1.5)) == double)); |
| static assert(is(typeof(func1b(1.5, [1,2,3])) == double)); |
| static assert(is(typeof(func1a(["a","b"], "s"c)) == string)); |
| static assert(is(typeof(func1b("s"c, ["a","b"])) == string)); |
| static assert(is(typeof(func1a(["a","b"], "s"w)) == wstring)); |
| static assert(is(typeof(func1b("s"w, ["a","b"])) == wstring)); |
| static assert(is(typeof(func1a(["a","b"], "s"d)) == dstring)); |
| static assert(is(typeof(func1b("s"d, ["a","b"])) == dstring)); |
| |
| auto func2a(K, V)(V[K], K, V) { return V[K].init; } |
| auto func2b(K, V)(V, K, V[K]) { return V[K].init; } |
| |
| static assert(is(typeof(func2a(aa, 1, 1)) == short[short])); |
| static assert(is(typeof(func2b(1, 1, aa)) == short[short])); |
| static assert(is(typeof(func2a([1:10,2:20,3:30], 1L, 10L)) == long[long])); |
| static assert(is(typeof(func2b(1L, 10L, [1:20,2:20,3:30])) == long[long])); |
| |
| auto func3a(T)(T, T) { return T.init; } |
| auto func3b(T)(T, T) { return T.init; } |
| |
| static assert(is(typeof(func3a(arrS, null)) == short[])); |
| static assert(is(typeof(func3b(null, arrS)) == short[])); |
| static assert(is(typeof(func3a(arrR, null)) == real[])); |
| static assert(is(typeof(func3b(null, arrR)) == real[])); |
| static assert(is(typeof(func3a(cstr, "str")) == string)); |
| static assert(is(typeof(func3b("str", cstr)) == string)); |
| static assert(is(typeof(func3a(wstr, "str")) == wstring)); |
| static assert(is(typeof(func3b("str", wstr)) == wstring)); |
| static assert(is(typeof(func3a(dstr, "str")) == dstring)); |
| static assert(is(typeof(func3b("str", dstr)) == dstring)); |
| static assert(is(typeof(func3a("str1" , "str2"c)) == string)); |
| static assert(is(typeof(func3b("str1"c, "str2" )) == string)); |
| static assert(is(typeof(func3a("str1" , "str2"w)) == wstring)); |
| static assert(is(typeof(func3b("str1"w, "str2" )) == wstring)); |
| static assert(is(typeof(func3a("str1" , "str2"d)) == dstring)); |
| static assert(is(typeof(func3b("str1"d, "str2" )) == dstring)); |
| |
| inout(V) get(K, V)(inout(V[K]) aa, K key, lazy V defaultValue) { return V.init; } |
| |
| short[short] hash12220; |
| short res12220 = get(hash12220, 1, 1); |
| |
| short[short] hash12221; |
| enum Key12221 : short { a } |
| get(hash12221, Key12221.a, Key12221.a); |
| |
| int[][string] mapping13026; |
| int[] v = get(mapping13026, "test", []); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12292 |
| |
| void test12292() |
| { |
| void fun(T : string)(T data) {} |
| |
| ubyte[3] sa; |
| static assert(!__traits(compiles, fun(sa))); |
| static assert(!__traits(compiles, { alias f = fun!(ubyte[3]); })); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12376 |
| |
| static auto encode12376(size_t sz)(dchar ch) if (sz > 1) |
| { |
| undefined; |
| } |
| |
| void test12376() |
| { |
| enum x = __traits(compiles, encode12376!2(x)); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12447 |
| |
| enum test12447(string str) = str; // [1] |
| string test12447(T...)(T args) if (T.length) { return args[0]; } // [2] |
| |
| // With [1]: The template parameter str cannot be be deduced -> no match |
| // With [2]: T is deduced to a type tuple (string), then match to the function call. |
| static assert(test12447("foo") == "foo"); |
| |
| // With [1]: template parameter str is deduced to "bar", then match. |
| // With [2]: T is deduced to an expression tuple ("bar"), but it will make invalid the function signature (T args). |
| // The failure should be masked silently and prefer the 1st version. |
| static assert(test12447!("bar") == "bar"); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12651 |
| |
| alias TemplateArgsOf12651(alias T : Base!Args, alias Base, Args...) = Args; |
| |
| struct S12651(T) { } |
| |
| static assert(!__traits(compiles, TemplateArgsOf12651!(S12651!int, S, float))); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12719 |
| |
| struct A12719 |
| { |
| B12719!int b(); |
| } |
| |
| struct B12719(T) |
| { |
| A12719 a; |
| void m() |
| { |
| auto v = B12719!T.init; |
| } |
| } |
| |
| // -------- |
| |
| enum canDoIt12719(R) = is(typeof(W12719!R)); |
| |
| struct W12719(R) |
| { |
| R r; |
| static if (canDoIt12719!R) {} |
| } |
| |
| W12719!int a12719; |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12746 |
| |
| template foo12746() |
| { |
| void bar() |
| { |
| static assert(!__traits(compiles, bar(1))); |
| } |
| alias foo12746 = bar; |
| } |
| |
| void foo12746(int) |
| { |
| assert(0); |
| } |
| |
| void test12746() |
| { |
| foo12746(); // instantiate |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12748 |
| |
| void foo12748(S, C : typeof(S.init[0]))(S s, C c) |
| { |
| } |
| |
| void test12748() |
| { |
| foo12748("abc", 'd'); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=9708 |
| |
| struct S9708 |
| { |
| void f()(inout(Object)) inout {} |
| } |
| |
| void test9708() |
| { |
| S9708 s; |
| s.f(new Object); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=12880 |
| |
| void f12880(T)(in T value) { static assert(is(T == string)); } |
| void test12880() { f12880(string.init); } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13087 |
| |
| struct Vec13087 |
| { |
| int x; |
| void m() { auto n = component13087!(this, 'x'); } |
| void c() const { auto n = component13087!(this, 'x'); } |
| void w() inout { auto n = component13087!(this, 'x'); } |
| void wc() inout const { auto n = component13087!(this, 'x'); } |
| void s() shared { auto n = component13087!(this, 'x'); } |
| void sc() shared const { auto n = component13087!(this, 'x'); } |
| void sw() shared inout { auto n = component13087!(this, 'x'); } |
| void swc() shared inout const { auto n = component13087!(this, 'x'); } |
| void i() immutable { auto n = component13087!(this, 'x'); } |
| } |
| |
| template component13087(alias vec, char c) |
| { |
| alias component13087 = vec.x; |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13127 |
| |
| /+void test13127(inout int = 0) |
| { |
| int [] ma1; |
| const(int)[] ca1; |
| const(int[]) ca2; |
| inout( int)[] wma1; |
| inout( int[]) wma2; |
| inout(const int)[] wca1; |
| inout(const int[]) wca2; |
| immutable(int)[] ia1; |
| immutable(int[]) ia2; |
| shared( int)[] sma1; |
| shared( int[]) sma2; |
| shared( const int)[] sca1; |
| shared( const int[]) sca2; |
| shared(inout int)[] swma1; |
| shared(inout int[]) swma2; |
| shared(inout const int)[] swca1; |
| shared(inout const int[]) swca2; |
| |
| /* In all cases, U should be deduced to top-unqualified type. |
| */ |
| |
| /* Parameter is (shared) mutable |
| */ |
| U f_m(U)( U) { return null; } |
| U fsm(U)(shared U) { return null; } |
| // 9 * 2 - 1 |
| static assert(is(typeof(f_m( ma1)) == int [])); |
| static assert(is(typeof(f_m( ca1)) == const(int)[])); |
| static assert(is(typeof(f_m( ca2)) == const(int)[])); |
| static assert(is(typeof(f_m( wma1)) == inout( int)[])); |
| static assert(is(typeof(f_m( wma2)) == inout( int)[])); |
| static assert(is(typeof(f_m( wca1)) == inout(const int)[])); |
| static assert(is(typeof(f_m( wca2)) == inout(const int)[])); |
| static assert(is(typeof(f_m( ia1)) == immutable(int)[])); |
| static assert(is(typeof(f_m( ia2)) == immutable(int)[])); |
| static assert(is(typeof(f_m( sma1)) == shared( int)[])); |
| static assert(is(typeof(f_m( sma2)) == shared( int)[])); // <- shared(int[]) |
| static assert(is(typeof(f_m( sca1)) == shared( const int)[])); |
| static assert(is(typeof(f_m( sca2)) == shared( const int)[])); // <- shared(const(int)[]) |
| static assert(is(typeof(f_m(swma1)) == shared(inout int)[])); |
| static assert(is(typeof(f_m(swma2)) == shared(inout int)[])); // <- shared(inout(int[])) |
| static assert(is(typeof(f_m(swca1)) == shared(inout const int)[])); |
| static assert(is(typeof(f_m(swca2)) == shared(inout const int)[])); // <- shared(inout(const(int))[]) |
| // 9 * 2 - 1 |
| static assert(is(typeof(fsm( ma1))) == false); |
| static assert(is(typeof(fsm( ca1))) == false); |
| static assert(is(typeof(fsm( ca2))) == false); |
| static assert(is(typeof(fsm( wma1))) == false); |
| static assert(is(typeof(fsm( wma2))) == false); |
| static assert(is(typeof(fsm( wca1))) == false); |
| static assert(is(typeof(fsm( wca2))) == false); |
| static assert(is(typeof(fsm( ia1))) == false); |
| static assert(is(typeof(fsm( ia2))) == false); |
| static assert(is(typeof(fsm( sma1)) == shared( int)[])); // <- NG |
| static assert(is(typeof(fsm( sma2)) == shared( int)[])); |
| static assert(is(typeof(fsm( sca1)) == shared( const int)[])); // <- NG |
| static assert(is(typeof(fsm( sca2)) == shared( const int)[])); |
| static assert(is(typeof(fsm(swma1)) == shared(inout int)[])); // <- NG |
| static assert(is(typeof(fsm(swma2)) == shared(inout int)[])); |
| static assert(is(typeof(fsm(swca1)) == shared(inout const int)[])); // <- NG |
| static assert(is(typeof(fsm(swca2)) == shared(inout const int)[])); |
| |
| /* Parameter is (shared) const |
| */ |
| U f_c(U)( const U) { return null; } |
| U fsc(U)(shared const U) { return null; } |
| // 9 * 2 - 1 |
| static assert(is(typeof(f_c( ma1)) == int [])); |
| static assert(is(typeof(f_c( ca1)) == const(int)[])); |
| static assert(is(typeof(f_c( ca2)) == const(int)[])); |
| static assert(is(typeof(f_c( wma1)) == inout( int)[])); |
| static assert(is(typeof(f_c( wma2)) == inout( int)[])); |
| static assert(is(typeof(f_c( wca1)) == inout(const int)[])); |
| static assert(is(typeof(f_c( wca2)) == inout(const int)[])); |
| static assert(is(typeof(f_c( ia1)) == immutable(int)[])); |
| static assert(is(typeof(f_c( ia2)) == immutable(int)[])); |
| static assert(is(typeof(f_c( sma1)) == shared( int)[])); |
| static assert(is(typeof(f_c( sma2)) == shared( int)[])); // <- shared(int[]) |
| static assert(is(typeof(f_c( sca1)) == shared( const int)[])); |
| static assert(is(typeof(f_c( sca2)) == shared( const int)[])); // <- shared(const(int)[]) |
| static assert(is(typeof(f_c(swma1)) == shared(inout int)[])); |
| static assert(is(typeof(f_c(swma2)) == shared(inout int)[])); // shared(inout(int)[]) |
| static assert(is(typeof(f_c(swca1)) == shared(inout const int)[])); |
| static assert(is(typeof(f_c(swca2)) == shared(inout const int)[])); // shared(inout(const(int))[]) |
| // 9 * 2 - 1 |
| static assert(is(typeof(fsc( ma1))) == false); |
| static assert(is(typeof(fsc( ca1))) == false); |
| static assert(is(typeof(fsc( ca2))) == false); |
| static assert(is(typeof(fsc( wma1))) == false); |
| static assert(is(typeof(fsc( wma2))) == false); |
| static assert(is(typeof(fsc( wca1))) == false); |
| static assert(is(typeof(fsc( wca2))) == false); |
| static assert(is(typeof(fsc( ia1)) == immutable(int)[])); // <- NG |
| static assert(is(typeof(fsc( ia2)) == immutable(int)[])); // <- NG |
| static assert(is(typeof(fsc( sma1)) == shared( int)[])); // <- NG |
| static assert(is(typeof(fsc( sma2)) == shared( int)[])); |
| static assert(is(typeof(fsc( sca1)) == shared( const int)[])); // <- NG |
| static assert(is(typeof(fsc( sca2)) == shared( const int)[])); |
| static assert(is(typeof(fsc(swma1)) == shared(inout int)[])); // <- NG |
| static assert(is(typeof(fsc(swma2)) == shared(inout int)[])); |
| static assert(is(typeof(fsc(swca1)) == shared(inout const int)[])); // <- NG |
| static assert(is(typeof(fsc(swca2)) == shared(inout const int)[])); |
| |
| /* Parameter is immutable |
| */ |
| U fi(U)(immutable U) { return null; } |
| // 9 * 2 - 1 |
| static assert(is(typeof(fi( ma1))) == false); |
| static assert(is(typeof(fi( ca1))) == false); |
| static assert(is(typeof(fi( ca2))) == false); |
| static assert(is(typeof(fi( wma1))) == false); |
| static assert(is(typeof(fi( wma2))) == false); |
| static assert(is(typeof(fi( wca1))) == false); |
| static assert(is(typeof(fi( wca2))) == false); |
| static assert(is(typeof(fi( ia1)) == immutable(int)[])); // <- NG |
| static assert(is(typeof(fi( ia2)) == immutable(int)[])); // <- NG |
| static assert(is(typeof(fi( sma1))) == false); |
| static assert(is(typeof(fi( sma2))) == false); |
| static assert(is(typeof(fi( sca1))) == false); |
| static assert(is(typeof(fi( sca2))) == false); |
| static assert(is(typeof(fi(swma1))) == false); |
| static assert(is(typeof(fi(swma2))) == false); |
| static assert(is(typeof(fi(swca1))) == false); |
| static assert(is(typeof(fi(swca2))) == false); |
| |
| /* Parameter is (shared) inout |
| */ |
| U f_w(U)( inout U) { return null; } |
| U fsw(U)(shared inout U) { return null; } |
| // 9 * 2 - 1 |
| static assert(is(typeof(f_w( ma1)) == int [])); |
| static assert(is(typeof(f_w( ca1)) == int [])); // <- const(int)[] |
| static assert(is(typeof(f_w( ca2)) == int [])); // <- const(int)[] |
| static assert(is(typeof(f_w( wma1)) == int [])); // <- inout(int)[] |
| static assert(is(typeof(f_w( wma2)) == int [])); // <- inout(int)[] |
| static assert(is(typeof(f_w( wca1)) == const(int)[])); // <- inout(const(int))[] |
| static assert(is(typeof(f_w( wca2)) == const(int)[])); // <- inout(const(int))[] |
| static assert(is(typeof(f_w( ia1)) == int [])); // <- immutable(int)[] |
| static assert(is(typeof(f_w( ia2)) == int [])); // <- immutable(int)[] |
| static assert(is(typeof(f_w( sma1)) == shared( int)[])); |
| static assert(is(typeof(f_w( sma2)) == shared( int)[])); // <- shared(int[]) |
| static assert(is(typeof(f_w( sca1)) == shared( int)[])); // <- shared(const(int))[] |
| static assert(is(typeof(f_w( sca2)) == shared( int)[])); // <- shared(const(int)[]) |
| static assert(is(typeof(f_w(swma1)) == shared( int)[])); // <- shared(inout(int))[] |
| static assert(is(typeof(f_w(swma2)) == shared( int)[])); // <- shared(inout(int)[]) |
| static assert(is(typeof(f_w(swca1)) == shared(const int)[])); // <- shared(inout(const(int)))[] |
| static assert(is(typeof(f_w(swca2)) == shared(const int)[])); // <- shared(inout(const(int))[]) |
| // 9 * 2 - 1 |
| static assert(is(typeof(fsw( ma1))) == false); |
| static assert(is(typeof(fsw( ca1))) == false); |
| static assert(is(typeof(fsw( ca2))) == false); |
| static assert(is(typeof(fsw( wma1))) == false); |
| static assert(is(typeof(fsw( wma2))) == false); |
| static assert(is(typeof(fsw( wca1))) == false); |
| static assert(is(typeof(fsw( wca2))) == false); |
| static assert(is(typeof(fsw( ia1)) == int [])); // <- NG |
| static assert(is(typeof(fsw( ia2)) == int [])); // <- NG |
| static assert(is(typeof(fsw( sma1)) == int [])); // <- NG |
| static assert(is(typeof(fsw( sma2)) == int [])); |
| static assert(is(typeof(fsw( sca1)) == int [])); // <- NG |
| static assert(is(typeof(fsw( sca2)) == int [])); // const(int)[] |
| static assert(is(typeof(fsw(swma1)) == int [])); // <- NG |
| static assert(is(typeof(fsw(swma2)) == int [])); // inout(int)[] |
| static assert(is(typeof(fsw(swca1)) == const(int)[])); // <- NG |
| static assert(is(typeof(fsw(swca2)) == const(int)[])); // <- inout(const(int))[] |
| |
| /* Parameter is (shared) inout const |
| */ |
| U f_wc(U)( inout const U) { return null; } |
| U fswc(U)(shared inout const U) { return null; } |
| // 9 * 2 - 1 |
| static assert(is(typeof(f_wc( ma1)) == int [])); |
| static assert(is(typeof(f_wc( ca1)) == int [])); // <- const(int)[] |
| static assert(is(typeof(f_wc( ca2)) == int [])); // <- const(int)[] |
| static assert(is(typeof(f_wc( wma1)) == int [])); // <- inout(int)[] |
| static assert(is(typeof(f_wc( wma2)) == int [])); // <- inout(int)[] |
| static assert(is(typeof(f_wc( wca1)) == int [])); // <- inout(const(int))[] |
| static assert(is(typeof(f_wc( wca2)) == int [])); // <- inout(const(int))[] |
| static assert(is(typeof(f_wc( ia1)) == int [])); // <- immutable(int)[] |
| static assert(is(typeof(f_wc( ia2)) == int [])); // <- immutable(int)[] |
| static assert(is(typeof(f_wc( sma1)) == shared(int)[])); |
| static assert(is(typeof(f_wc( sma2)) == shared(int)[])); // <- shared(int[]) |
| static assert(is(typeof(f_wc( sca1)) == shared(int)[])); // <- shared(const(int))[] |
| static assert(is(typeof(f_wc( sca2)) == shared(int)[])); // <- shared(const(int)[]) |
| static assert(is(typeof(f_wc(swma1)) == shared(int)[])); // <- shared(inout(int))[] |
| static assert(is(typeof(f_wc(swma2)) == shared(int)[])); // <- shared(inout(int)[]) |
| static assert(is(typeof(f_wc(swca1)) == shared(int)[])); // <- shared(inout(const(int)))[] |
| static assert(is(typeof(f_wc(swca2)) == shared(int)[])); // <- shared(inout(const(int))[]) |
| // 9 * 2 - 1 |
| static assert(is(typeof(fswc( ma1))) == false); |
| static assert(is(typeof(fswc( ca1))) == false); |
| static assert(is(typeof(fswc( ca2))) == false); |
| static assert(is(typeof(fswc( wma1))) == false); |
| static assert(is(typeof(fswc( wma2))) == false); |
| static assert(is(typeof(fswc( wca1))) == false); |
| static assert(is(typeof(fswc( wca2))) == false); |
| static assert(is(typeof(fswc( ia1)) == int [])); // <- NG |
| static assert(is(typeof(fswc( ia2)) == int [])); // <- NG |
| static assert(is(typeof(fswc( sma1)) == int [])); // <- NG |
| static assert(is(typeof(fswc( sma2)) == int [])); |
| static assert(is(typeof(fswc( sca1)) == int [])); // <- NG |
| static assert(is(typeof(fswc( sca2)) == int [])); // <- const(int)[] |
| static assert(is(typeof(fswc(swma1)) == int [])); // <- NG |
| static assert(is(typeof(fswc(swma2)) == int [])); // <- inout(int)[] |
| static assert(is(typeof(fswc(swca1)) == int [])); // <- NG |
| static assert(is(typeof(fswc(swca2)) == int [])); // <- inout(const(int))[] |
| }+/ |
| |
| void test13127a() |
| { |
| void foo(T)(in T[] src, T[] dst) { static assert(is(T == int[])); } |
| |
| int[][] a; |
| foo(a, a); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13159 |
| |
| template maxSize13159(T...) |
| { |
| static if (T.length == 1) |
| { |
| enum size_t maxSize13159 = T[0].sizeof; |
| } |
| else |
| { |
| enum size_t maxSize13159 = |
| T[0].sizeof >= maxSize13159!(T[1 .. $]) |
| ? T[0].sizeof |
| : maxSize13159!(T[1 .. $]); |
| } |
| } |
| |
| struct Node13159 |
| { |
| struct Pair |
| { |
| Node13159 value; |
| } |
| |
| //alias Algebraic!(Node[], int) Value; |
| enum n = maxSize13159!(Node13159[], int); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13180 |
| |
| void test13180() |
| { |
| inout(V) get1a(K, V)(inout(V[K]) aa, lazy inout(V) defaultValue) |
| { |
| static assert(is(V == string)); |
| static assert(is(K == string)); |
| return defaultValue; |
| } |
| inout(V) get1b(K, V)(lazy inout(V) defaultValue, inout(V[K]) aa) |
| { |
| static assert(is(V == string)); |
| static assert(is(K == string)); |
| return defaultValue; |
| } |
| |
| inout(V) get2a(K, V)(inout(V)[K] aa, lazy inout(V) defaultValue) |
| { |
| static assert(is(V == string)); |
| static assert(is(K == string)); |
| return defaultValue; |
| } |
| inout(V) get2b(K, V)(lazy inout(V) defaultValue, inout(V)[K] aa) |
| { |
| static assert(is(V == string)); |
| static assert(is(K == string)); |
| return defaultValue; |
| } |
| string def; |
| string[string] aa; |
| string s1a = get1a(aa, def); |
| string s1b = get1b(def, aa); |
| string s2a = get2a(aa, def); |
| string s2b = get2b(def, aa); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13204 |
| |
| struct A13204(uint v) |
| { |
| alias whatever = A13204y; |
| static assert(is(whatever == A13204)); |
| } |
| alias A13204x = A13204!1; |
| alias A13204y = A13204x; |
| |
| struct B13204(uint v) |
| { |
| alias whatever = B13204z; |
| static assert(is(whatever == B13204)); |
| } |
| alias B13204x = B13204!1; |
| alias B13204y = B13204x; |
| alias B13204z = B13204y; |
| |
| void test13204() |
| { |
| static assert(is(A13204x == A13204!1)); |
| static assert(is(A13204x == A13204!1.whatever)); |
| static assert(is(A13204x == A13204y)); |
| |
| static assert(is(B13204x == B13204!1)); |
| static assert(is(B13204x == B13204!1.whatever)); |
| static assert(is(B13204x == B13204y)); |
| static assert(is(B13204x == B13204z)); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=8462 (dup of 13204) |
| |
| alias FP8462 = void function(C8462.Type arg); |
| |
| class C8462 |
| { |
| enum Type { Foo } |
| alias funcPtrPtr = FP8462*; |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13218 |
| |
| template isCallable13218(T...) |
| if (T.length == 1) |
| { |
| static assert(0); |
| } |
| |
| template ParameterTypeTuple13218(func...) |
| if (func.length == 1 && isCallable13218!func) |
| { |
| static assert(0); |
| } |
| |
| struct R13218 |
| { |
| private static string mangleFuncPtr(ArgTypes...)() |
| { |
| string result = "fnp_"; |
| foreach (T; ArgTypes) |
| result ~= T.mangleof; |
| return result; |
| } |
| void function(int) fnp_i; |
| double delegate(double) fnp_d; |
| |
| void opAssign(FnT)(FnT func) |
| { |
| mixin(mangleFuncPtr!( ParameterTypeTuple13218!FnT) ~ " = func;"); // parsed as TypeInstance |
| //mixin(mangleFuncPtr!(.ParameterTypeTuple13218!FnT) ~ " = func;"); // parsed as DotTemplateInstanceExp -> works |
| } |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13219 |
| |
| struct Map13219(V) {} |
| |
| void test13219a(alias F, VA, VB)(Map13219!VA a, Map13219!VB b) |
| if (is(VA : typeof(F(VA.init, VB.init)))) |
| {} |
| |
| void test13219b(alias F)() |
| { |
| test13219a!((a, b) => b)(Map13219!int.init, Map13219!int.init); |
| } |
| |
| void test13219() |
| { |
| int x; |
| test13219b!x(); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13223 |
| |
| void test13223() |
| { |
| T[] f1(T)(T[] a1, T[] a2) |
| { |
| static assert(is(T == int)); |
| return a1 ~ a2; |
| } |
| T[] f2(T)(T[] a1, T[] a2) |
| { |
| static assert(is(T == int)); |
| return a1 ~ a2; |
| } |
| int[] a = [1, 2]; |
| static assert(is(typeof(f1(a, [])) == int[])); |
| static assert(is(typeof(f2([], a)) == int[])); |
| static assert(is(typeof(f1(a, null)) == int[])); |
| static assert(is(typeof(f2(null, a)) == int[])); |
| |
| T[] f3(T)(T[] a) { return a; } |
| static assert(is(typeof(f3([])) == void[])); |
| static assert(is(typeof(f3(null)) == void[])); |
| |
| T f4(T)(T a) { return a; } |
| static assert(is(typeof(f4([])) == void[])); |
| static assert(is(typeof(f4(null)) == typeof(null))); |
| |
| T[][] f5(T)(T[][] a) { return a; } |
| static assert(is(typeof(f5([])) == void[][])); |
| static assert(is(typeof(f5(null)) == void[][])); |
| |
| void translate(C = immutable char)(const(C)[] toRemove) |
| { |
| static assert(is(C == char)); |
| } |
| translate(null); |
| } |
| |
| void test13223a() |
| { |
| T f(T)(T, T) { return T.init; } |
| |
| immutable i = 0; |
| const c = 0; |
| auto m = 0; |
| shared s = 0; |
| |
| static assert(is(typeof(f(i, i)) == immutable int)); |
| static assert(is(typeof(f(i, c)) == const int)); |
| static assert(is(typeof(f(c, i)) == const int)); |
| static assert(is(typeof(f(i, m)) == int)); |
| static assert(is(typeof(f(m, i)) == int)); |
| static assert(is(typeof(f(c, m)) == int)); |
| static assert(is(typeof(f(m, c)) == int)); |
| static assert(is(typeof(f(m, m)) == int)); |
| static assert(is(typeof(f(i, s)) == shared int)); |
| static assert(is(typeof(f(s, i)) == shared int)); |
| static assert(is(typeof(f(c, s)) == shared int)); |
| static assert(is(typeof(f(s, c)) == shared int)); |
| static assert(is(typeof(f(s, s)) == shared int)); |
| static assert(is(typeof(f(s, m)) == int)); |
| static assert(is(typeof(f(m, s)) == int)); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13235 |
| |
| struct Tuple13235(T...) |
| { |
| T expand; |
| alias expand field; |
| |
| this(T values) |
| { |
| field = values; |
| } |
| } |
| struct Foo13235 |
| { |
| Tuple13235!(int, Foo13235)* foo; |
| } |
| |
| template Inst13235(T...) |
| { |
| struct Tuple |
| { |
| T expand; |
| alias expand field; |
| |
| this(T values) |
| { |
| field = values; |
| } |
| } |
| alias Inst13235 = Tuple*; |
| } |
| struct Bar13235 |
| { |
| Inst13235!(int, Bar13235) bar; |
| } |
| |
| void test13235() |
| { |
| alias Tup1 = Tuple13235!(int, Foo13235); |
| assert(Tup1(1, Foo13235()).expand[0] == 1); |
| |
| alias Tup2 = typeof(*Inst13235!(int, Bar13235).init); |
| assert(Tup2(1, Bar13235()).expand[0] == 1); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13252 |
| |
| alias TypeTuple13252(T...) = T; |
| |
| static assert(is(typeof(TypeTuple13252!(cast(int )1)[0]) == int )); |
| static assert(is(typeof(TypeTuple13252!(cast(long)1)[0]) == long)); |
| |
| static assert(is(typeof(TypeTuple13252!(cast(float )3.14)[0]) == float )); |
| static assert(is(typeof(TypeTuple13252!(cast(double)3.14)[0]) == double)); |
| |
| static assert(is(typeof(TypeTuple13252!(cast(string )null)[0]) == string )); |
| static assert(is(typeof(TypeTuple13252!(cast(string[])null)[0]) == string[])); // OK <- NG |
| |
| static assert(is(typeof(TypeTuple13252!(cast(wstring)"abc")[0]) == wstring)); |
| static assert(is(typeof(TypeTuple13252!(cast(dstring)"abc")[0]) == dstring)); |
| |
| static assert(is(typeof(TypeTuple13252!(cast(int[] )[])[0]) == int[] )); |
| static assert(is(typeof(TypeTuple13252!(cast(long[])[])[0]) == long[])); // OK <- NG |
| |
| struct S13252 { } |
| static assert(is(typeof(TypeTuple13252!(const S13252())[0]) == const(S13252))); |
| static assert(is(typeof(TypeTuple13252!(immutable S13252())[0]) == immutable(S13252))); // OK <- NG |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13294 |
| |
| void test13294() |
| { |
| void f(T)(const ref T src, ref T dst) |
| { |
| pragma(msg, "T = ", T); |
| static assert(!is(T == const)); |
| } |
| { |
| const byte src; |
| byte dst; |
| f(src, dst); |
| } |
| { |
| const char src; |
| char dst; |
| f(src, dst); |
| } |
| |
| // https://issues.dlang.org/show_bug.cgi?id=13351 |
| T add(T)(in T x, in T y) |
| { |
| T z; |
| z = x + y; |
| return z; |
| } |
| const double a = 1.0; |
| const double b = 2.0; |
| double c; |
| c = add(a,b); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13299 |
| |
| struct Foo13299 |
| { |
| Foo13299 opDispatch(string name)(int a, int[] b...) |
| if (name == "bar") |
| { |
| return Foo13299(); |
| } |
| |
| Foo13299 opDispatch(string name)() |
| if (name != "bar") |
| { |
| return Foo13299(); |
| } |
| } |
| |
| void test13299() |
| { |
| Foo13299() |
| .bar(0) |
| .bar(1) |
| .bar(2); |
| |
| Foo13299() |
| .opDispatch!"bar"(0) |
| .opDispatch!"bar"(1) |
| .opDispatch!"bar"(2); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13333 |
| |
| template AliasThisTypeOf13333(T) |
| { |
| static assert(0, T.stringof); // T.stringof is important |
| } |
| |
| template StaticArrayTypeOf13333(T) |
| { |
| static if (is(AliasThisTypeOf13333!T AT)) |
| alias X = StaticArrayTypeOf13333!AT; |
| else |
| alias X = T; |
| |
| static if (is(X : E[n], E, size_t n)) |
| alias StaticArrayTypeOf13333 = X; |
| else |
| static assert(0, T.stringof~" is not a static array type"); |
| } |
| |
| enum bool isStaticArray13333(T) = is(StaticArrayTypeOf13333!T); |
| |
| struct VaraiantN13333(T) |
| { |
| static if (isStaticArray13333!T) |
| ~this() { static assert(0); } |
| } |
| |
| struct DummyScope13333 |
| { |
| alias A = VaraiantN13333!C; |
| |
| static class C |
| { |
| A entity; |
| } |
| } |
| |
| void test13333() |
| { |
| struct DummyScope |
| { |
| alias A = VaraiantN13333!C; |
| |
| static class C |
| { |
| A entity; |
| } |
| } |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13374 |
| |
| int f13374(alias a)() { return 1; } |
| int f13374(string s)() { return 2; } |
| |
| void x13374(int i) {} |
| |
| void test13374() |
| { |
| assert(f13374!x13374() == 1); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14109 |
| |
| string f14109() { return "a"; } |
| string g14109()() { return "a"; } |
| |
| struct S14109(string s) { static assert(s == "a"); } |
| |
| alias X14109 = S14109!(f14109); |
| alias Y14109 = S14109!(g14109!()); |
| static assert(is(X14109 == Y14109)); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13378 |
| |
| struct Vec13378(size_t n, T, string as) |
| { |
| T[n] data; |
| } |
| |
| void doSome13378(size_t n, T, string as)(Vec13378!(n,T,as) v) {} |
| |
| void test13378() |
| { |
| auto v = Vec13378!(3, float, "xyz")([1,2,3]); |
| doSome13378(v); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13379 |
| |
| void test13379() |
| { |
| match13379(""); |
| } |
| |
| auto match13379(RegEx )(RegEx re) |
| if (is(RegEx == Regex13379!char)) // #1 Regex!char (speculative && tinst == NULL) |
| {} |
| auto match13379(String)(String re) |
| {} |
| |
| struct Regex13379(Char) |
| { |
| ShiftOr13379!Char kickstart; // #2 ShiftOr!char (speculative && tinst == Regex!char) |
| } |
| struct ShiftOr13379(Char) |
| { |
| this(ref Regex13379!Char re) // #3 Regex!Char (speculative && tinst == ShiftOr!char) |
| { |
| uint n_length; |
| uint idx; |
| n_length = min13379(idx, n_length); |
| } |
| } |
| |
| template MinType13379(T...) |
| { |
| alias MinType13379 = T[0]; |
| } |
| MinType13379!T min13379(T...)(T args) // #4 MinType!uint (speculative && thist == ShiftOr!char) |
| { |
| alias a = args[0]; |
| alias b = args[$-1]; |
| return cast(typeof(return)) (a < b ? a : b); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13417 |
| |
| struct V13417(size_t N, E, alias string AS) |
| { |
| } |
| |
| auto f13417(E)(in V13417!(4, E, "ijka")) |
| { |
| return V13417!(3, E, "xyz")(); |
| } |
| |
| void test13417() |
| { |
| f13417(V13417!(4, float, "ijka")()); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13484 |
| |
| int foo13484()(void delegate() hi) { return 1; } |
| int foo13484(T)(void delegate(T) hi) { return 2; } |
| |
| void test13484() |
| { |
| assert(foo13484({}) == 1); // works |
| assert(foo13484((float v){}) == 2); // works <- throws error |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13675 |
| |
| enum E13675; |
| |
| bool foo13675(T : E13675)() |
| { |
| return false; |
| } |
| |
| void test13675() |
| { |
| if (foo13675!E13675) |
| {} |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13694 |
| |
| auto foo13694(T)(string A, T[] G ...) { return 1; } |
| auto foo13694(T)(string A, long E, T[] G ...) { return 2; } |
| |
| void test13694() |
| { |
| struct S {} |
| |
| S v; |
| assert(foo13694("A", v) == 1); // <- OK |
| assert(foo13694("A", 0, v) == 2); // <- used to be OK but now fails |
| assert(foo13694!S("A", 0, v) == 2); // <- workaround solution |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13760 |
| |
| void test13760() |
| { |
| void func(K, V)(inout(V[K]) aa, inout(V) val) {} |
| |
| class C {} |
| C[int] aa; |
| func(aa, new C); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13714 |
| |
| struct JSONValue13714 |
| { |
| this(T)(T arg) |
| { |
| } |
| this(T : JSONValue13714)(inout T arg) inout |
| { |
| //store = arg.store; |
| } |
| |
| void opAssign(T)(T arg) |
| { |
| } |
| } |
| |
| void test13714() |
| { |
| enum DummyStringEnum |
| { |
| foo = "bar" |
| } |
| |
| JSONValue13714[string] aa; |
| aa["A"] = DummyStringEnum.foo; |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=13807 |
| |
| T f13807(T)(inout(T)[] arr) |
| { |
| return T.init; |
| } |
| |
| void test13807() |
| { |
| static assert(is(typeof(f13807([1, 2, 3])) == int)); // OK |
| static assert(is(typeof(f13807(["a", "b"])) == string)); // OK <- Error |
| static assert(is(typeof(f13807!string(["a", "b"])) == string)); // OK |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14174 |
| import imports.testmangle; |
| |
| struct Config14174(a, b) {} |
| |
| struct N14174 {} |
| |
| alias defConfig14174 = Config14174!(N14174, N14174); |
| |
| @safe @nogc pure nothrow |
| void accepter14174a(Config : Config14174!(T) = defConfig14174, T...)() |
| { |
| static assert(equalDemangle(accepter14174a.mangleof, |
| "_D7breaker131__T14"~ |
| "accepter14174a"~ |
| "HTS7breaker51__T11Config14174TS7breaker6N14174TS7breaker6N14174Z11Config14174TS7breaker6N14174TS7breaker6N14174Z14"~ |
| "accepter14174a"~ |
| "FNaNbNiNfZv")); |
| } |
| |
| @safe @nogc pure nothrow |
| void accepter14174b(Config : Config14174!(T) = defConfig14174, T...)() |
| { |
| static assert(equalDemangle(accepter14174b.mangleof, |
| "_D7breaker131__T14"~ |
| "accepter14174b"~ |
| "HTS7breaker51__T11Config14174TS7breaker6N14174TS7breaker6N14174Z11Config14174TS7breaker6N14174TS7breaker6N14174Z14"~ |
| "accepter14174b"~ |
| "FNaNbNiNfZv")); |
| } |
| |
| void test14174() |
| { |
| accepter14174a!()(); |
| |
| accepter14174b!()(); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14836 |
| |
| template a14836x(alias B, C...) |
| { |
| int a14836x(D...)() if (D.length == 0) { return 1; } |
| int a14836x(D...)(D d) if (D.length > 0) { return 2; } |
| } |
| template a14836y(alias B, C...) |
| { |
| int a14836y(T, D...)(T t) if (D.length == 0) { return 1; } |
| int a14836y(T, D...)(T t, D d) if (D.length > 0) { return 2; } |
| } |
| |
| void test14836() |
| { |
| int v; |
| assert(a14836x!(v)() == 1); |
| assert(a14836x!(v)(1) == 2); |
| assert(a14836y!(v)(1) == 1); |
| assert(a14836y!(v)(1, 2) == 2); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14357 |
| |
| template Qux14357(T : U*, U : V*, V) |
| { |
| pragma(msg, T); // no match <- float** |
| pragma(msg, U); // no match <- float* |
| pragma(msg, V); // no match <- int |
| enum Qux14357 = T.sizeof + V.sizeof; |
| } |
| static assert(!__traits(compiles, Qux14357!(float**, int*))); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14481 |
| |
| template someT14481(alias e) |
| { |
| alias someT14481 = e; |
| } |
| |
| mixin template Mix14481(alias e) |
| { |
| alias SomeAlias = someT14481!e; |
| } |
| |
| struct Hoge14481 |
| { |
| mixin Mix14481!e; |
| enum e = 10; |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14520 |
| |
| template M14520(alias a) { enum M14520 = 1; } |
| template M14520(string s) { enum M14520 = 2; } |
| |
| int f14520a(); |
| string f14520b() { assert(0); } |
| string f14520c() { return "a"; } |
| |
| static assert(M14520!f14520a == 1); |
| static assert(M14520!f14520b == 1); |
| static assert(M14520!f14520c == 1); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14568 |
| |
| struct Interval14568() |
| { |
| auto left = INVALID; |
| |
| auto opAssign()(Interval14568) { left; } |
| } |
| |
| auto interval14568(T)(T point) |
| { |
| Interval14568!(); |
| } |
| |
| alias Instantiate14568(alias symbol, Args...) = symbol!Args; |
| |
| template Match14568(patterns...) |
| { |
| static if (__traits(compiles, Instantiate14568!(patterns[0]))) |
| { |
| alias Match14568 = patterns[0]; |
| } |
| else static if (patterns.length == 1) |
| {} |
| } |
| |
| template SubOps14568(Args...) |
| { |
| auto opIndex() |
| { |
| template IntervalType(T...) |
| { |
| alias Point() = typeof(T.interval14568); |
| |
| alias IntervalType = Match14568!(Point); |
| } |
| alias Subspace = IntervalType!(Args); |
| } |
| } |
| |
| struct Nat14568 { mixin SubOps14568!(null); } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14603 |
| // https://issues.dlang.org/show_bug.cgi?id=14604 |
| |
| struct S14603 |
| { |
| template opDispatch(string name) |
| { |
| void opDispatch()() {} |
| } |
| } |
| alias a14603 = S14603.opDispatch!"go"; // OK |
| alias b14603 = S14603.go; // OK <- NG |
| |
| struct S14604 |
| { |
| template opDispatch(string name) |
| { |
| void opDispatch()() {} |
| } |
| } |
| alias Id14604(alias thing) = thing; |
| alias c14604 = Id14604!(S14604.opDispatch!"go"); // ok |
| alias d14604 = Id14604!(S14604.go); // issue 14604, 'Error: template instance opDispatch!"go" cannot resolve forward reference' |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14735 |
| |
| enum CS14735 { yes, no } |
| |
| int indexOf14735a(Range )(Range s, in dchar c) { return 1; } |
| int indexOf14735a(T, size_t n)(ref T[n] s, in dchar c) { return 2; } |
| |
| int indexOf14735b(Range )(Range s, in dchar c, in CS14735 cs = CS14735.yes) { return 1; } |
| int indexOf14735b(T, size_t n)(ref T[n] s, in dchar c, in CS14735 cs = CS14735.yes) { return 2; } |
| |
| void test14735() |
| { |
| char[64] buf; |
| |
| // Supported from 2.063: (https://dlang.org/changelog/2.063.html#implicitarraycast) |
| assert(indexOf14735a(buf[0..32], '\0') == 2); |
| assert(indexOf14735b(buf[0..32], '\0') == 2); |
| |
| // Have to work as same as above. |
| assert(indexOf14735a(buf[], '\0') == 2); |
| assert(indexOf14735b(buf[], '\0') == 2); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14743 |
| |
| class A14743 |
| { |
| auto func1 = (A14743 a) { a.func2!int(); }; |
| auto func2(T)() {} |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14802 |
| |
| void test14802() |
| { |
| auto func(T)(T x, T y) { return x; } |
| |
| struct S1 { double x; alias x this; } |
| struct S2 { double x; alias x this; } |
| S1 s1; |
| S2 s2; |
| |
| enum E1 : double { a = 1.0 } |
| enum E2 : double { a = 1.0 } |
| |
| static assert(is(typeof( func(1 , 1 ) ) == int)); |
| static assert(is(typeof( func(1u, 1u) ) == uint)); |
| static assert(is(typeof( func(1u, 1 ) ) == uint)); |
| static assert(is(typeof( func(1 , 1u) ) == uint)); |
| |
| static assert(is(typeof( func(1.0f, 1.0f) ) == float)); |
| static assert(is(typeof( func(1.0 , 1.0 ) ) == double)); |
| static assert(is(typeof( func(1.0 , 1.0f) ) == double)); |
| static assert(is(typeof( func(1.0f, 1.0 ) ) == double)); |
| |
| static assert(is(typeof( func(s1, s1) ) == S1)); |
| static assert(is(typeof( func(s2, s2) ) == S2)); |
| static assert(is(typeof( func(s1, s2) ) == double)); |
| static assert(is(typeof( func(s2, s1) ) == double)); |
| |
| static assert(is(typeof( func(E1.a, E1.a) ) == E1)); |
| static assert(is(typeof( func(E2.a, E2.a) ) == E2)); |
| static assert(is(typeof( func(E1.a, 1.0) ) == double)); |
| static assert(is(typeof( func(E2.a, 1.0) ) == double)); |
| static assert(is(typeof( func(1.0, E1.a) ) == double)); |
| static assert(is(typeof( func(1.0, E2.a) ) == double)); |
| static assert(is(typeof( func(E1.a, E2.a) ) == double)); |
| static assert(is(typeof( func(E2.a, E1.a) ) == double)); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=14886 |
| |
| void test14886() |
| { |
| alias R = int[100_000]; |
| |
| auto front(T)(T[] a) {} |
| front(R.init); |
| |
| auto bar1(T)(T, T[] a) { return T.init; } |
| auto bar2(T)(T[] a, T) { return T.init; } |
| |
| static assert(is(typeof(bar1(1L, R.init)) == long)); |
| static assert(is(typeof(bar2(R.init, 1L)) == long)); |
| // <-- T should be deduced to int because R.init is rvalue...? |
| |
| ubyte x; |
| static assert(is(typeof(bar1(x, R.init)) == int)); |
| static assert(is(typeof(bar2(R.init, x)) == int)); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15156 |
| |
| // https://issues.dlang.org/show_bug.cgi?id=15156 |
| auto f15116a(T)(string s, string arg2) { return 1; } |
| auto f15116b(T)(int i, string arg2) { return 2; } |
| |
| template bish15116(T) |
| { |
| alias bish15116 = f15116a!T; |
| alias bish15116 = f15116b!T; |
| } |
| |
| void test15116() |
| { |
| alias func = bish15116!string; |
| assert(func("", "") == 1); |
| assert(func(12, "") == 2); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15152 |
| |
| void test15152() |
| { |
| void func(string M)() { } |
| |
| struct S |
| { |
| enum name = "a"; |
| } |
| |
| enum s = S.init; |
| func!(s.name); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15352 |
| |
| struct S15352(T, T delegate(uint idx) supplier) |
| { |
| } |
| |
| auto make15352a(T, T delegate(uint idx) supplier)() |
| { |
| enum local = supplier; // OK |
| S15352!(T, local) ret; |
| return ret; |
| } |
| |
| auto make15352b(T, T delegate(uint idx) supplier)() |
| { |
| S15352!(T, supplier) ret; // OK <- Error |
| return ret; |
| } |
| |
| void test15352() |
| { |
| enum dg = delegate(uint idx) => idx; |
| auto s1 = S15352!(uint, dg)(); |
| auto s2 = make15352a!(uint, dg)(); |
| auto s3 = make15352b!(uint, dg)(); |
| assert(is(typeof(s1) == typeof(s2))); |
| assert(is(typeof(s1) == typeof(s3))); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15623 |
| |
| struct WithFoo15623a { void foo() {} } |
| struct WithFoo15623b { void foo() {} } |
| struct WithFoo15623c { void foo() {} } |
| struct WithFoo15623d { void foo() {} } |
| |
| struct WithoutFoo15623a {} |
| struct WithoutFoo15623b {} |
| struct WithoutFoo15623c {} |
| struct WithoutFoo15623d {} |
| |
| struct CallsFoo15623(T) |
| { |
| T t; |
| void bar() { t.foo(); } // error occurs during TemplateInstance.semantic3 |
| } |
| |
| // Instantiations outside of function bodies |
| static assert( is(CallsFoo15623!WithFoo15623a)); |
| static assert(!is(CallsFoo15623!WithoutFoo15623a)); // OK <- NG |
| static assert( __traits(compiles, CallsFoo15623!WithFoo15623b)); |
| static assert(!__traits(compiles, CallsFoo15623!WithoutFoo15623b)); // OK <- NG |
| |
| // Instantiations inside function bodies (OK) |
| static assert( is(typeof({ alias Baz = CallsFoo15623!WithFoo15623c; return Baz.init; }()))); |
| static assert(!is(typeof({ alias Baz = CallsFoo15623!WithoutFoo15623c; return Baz.init; }()))); |
| static assert( __traits(compiles, { alias Baz = CallsFoo15623!WithFoo15623d; return Baz.init; }())); |
| static assert(!__traits(compiles, { alias Baz = CallsFoo15623!WithoutFoo15623d; return Baz.init; }())); |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15781 |
| |
| void test15781() |
| { |
| static struct S |
| { |
| int value; |
| } |
| |
| T foo(T)(T a, T b) |
| { |
| return T(); |
| } |
| |
| const S cs; |
| S ms; |
| static assert(is(typeof(foo(ms, ms)) == S)); |
| static assert(is(typeof(foo(ms, cs)) == const S)); |
| static assert(is(typeof(foo(cs, ms)) == const S)); |
| static assert(is(typeof(foo(cs, cs)) == const S)); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=16042 |
| |
| struct Foo16042 {} |
| |
| auto map16042(alias func, T)(T t) |
| { |
| return func(t); |
| } |
| |
| auto toChars16042(R)(R r) if (is(R == int[])) |
| { |
| Foo16042 f; |
| assert(toChars16042(f) == 1); // OK |
| assert(map16042!(toChars16042)(f) == 1); // OK <- NG |
| assert(map16042!((toChars16042))(f) == 1); // OK |
| } |
| |
| auto toChars16042(Foo16042 f) |
| { |
| return 1; |
| } |
| |
| void test16042() |
| { |
| [1].toChars16042(); |
| } |
| |
| // --- |
| |
| auto fn16042(R)(R r) if (is(R == int[])) {} |
| auto fn16042(Foo16042 f) { return 1; } |
| |
| struct Namespace16042 |
| { |
| alias fn = fn16042!(int[]); |
| } |
| |
| void test16042b() |
| { |
| Foo16042 f; |
| |
| with (Namespace16042) |
| { |
| static assert(!__traits(compiles, fn(f))); // NG |
| static assert(!__traits(compiles, map16042!(fn)(f))); // should be NG -> actually NG |
| static assert(!__traits(compiles, map16042!((fn))(f))); // NG |
| } |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15243 |
| |
| struct S15243(Types...) |
| { |
| void apply1(U)(U delegate(Types[0]) f0) {} |
| |
| void apply2(U)(U delegate(Types) f0) {} |
| |
| void apply3(U)(U delegate(Types[1..$]) f0) {} |
| } |
| |
| void test15243() |
| { |
| int f1(int) { return 0; } |
| int f2(int, long) { return 0; } |
| int f3(long, string) { return 0; } |
| |
| S15243!(int) s1; |
| s1.apply1(&f1); |
| s1.apply2(&f1); |
| |
| S15243!(int, long) s2; |
| s2.apply2(&f2); |
| |
| S15243!(int, long, string) s3; |
| s3.apply3(&f3); |
| } |
| |
| /******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=15653 |
| |
| alias TypeTuple15653(T...) = T; |
| |
| void test15653() |
| { |
| void foo(U, T)(const T x) { static assert(is(T == U)); } |
| void bar(U, T)(immutable T x) { static assert(is(T == U)); } |
| |
| struct X { int a; long[2] b; } |
| struct Y { int* a; long[] b; } |
| |
| foreach (U; TypeTuple15653!( byte, short, int, long, |
| ubyte, ushort, uint, ulong, |
| float, double, real, |
| void delegate(), |
| int[2], X, X[2])) |
| { |
| foo!U(U.init); // OK |
| bar!U(U.init); // Was error, now OK |
| |
| U u; |
| foo!U(u); // OK |
| bar!U(u); // Was error, now OK |
| } |
| |
| foreach (U; TypeTuple15653!(void*, int**, long[], double*[2])) |
| { |
| foo!U(U.init); // OK |
| bar!U(U.init); // Was error, now OK |
| |
| U u; |
| foo!U(u); |
| static assert(!__traits(compiles, bar!U(u)), U.stringof); |
| } |
| |
| foreach (U; TypeTuple15653!(Object, Y, Y[2], int[int])) |
| { |
| foo!U(U.init); // OK |
| static assert(!__traits(compiles, bar!U(U.init)), U.stringof); |
| |
| U u; |
| foo!U(u); // OK |
| static assert(!__traits(compiles, bar!U(u)), U.stringof); |
| } |
| } |
| |
| /******************************************/ |
| |
| int main() |
| { |
| test1(); |
| test2(); |
| test3(); |
| test4(); |
| test5(); |
| test6(); |
| test7(); |
| test8(); |
| test9(); |
| test1780(); |
| test3608(); |
| test5893(); |
| test6404(); |
| test2246(); |
| test2296(); |
| bug4984(); |
| test2579(); |
| test2803(); |
| test6613(); |
| test5886(); |
| test5393(); |
| test5896(); |
| test6825(); |
| test6789(); |
| test2778(); |
| test2778aa(); |
| test2778get(); |
| test6208a(); |
| test6208b(); |
| test6208c(); |
| test6738(); |
| test6780(); |
| test6810(); |
| test6891(); |
| test6994(); |
| test6764(); |
| test3467(); |
| test4413(); |
| test5525(); |
| test5801(); |
| test10(); |
| test7037(); |
| test7124(); |
| test7359(); |
| test7416(); |
| test7563(); |
| test7572(); |
| test7580(); |
| test7585(); |
| test7671(); |
| test7672(); |
| test7684(); |
| test11a(); |
| test11b(); |
| test7769(); |
| test7873(); |
| test7933(); |
| test8094(); |
| test12(); |
| test8125(); |
| test13(); |
| test14(); |
| test8129(); |
| test8238(); |
| test8669(); |
| test8833(); |
| test8976(); |
| test8940(); |
| test9022(); |
| test9026(); |
| test9038(); |
| test9076(); |
| test9100(); |
| test9124a(); |
| test9124b(); |
| test9143(); |
| test9266(); |
| test9536(); |
| test9578(); |
| test9596(); |
| test9837(); |
| test9874(); |
| test9885(); |
| test9971(); |
| test9977(); |
| test10083(); |
| test10592(); |
| test11242(); |
| test10811(); |
| test10969(); |
| test11271(); |
| test11533(); |
| test11818(); |
| test11843(); |
| test11872(); |
| test12122(); |
| test12207(); |
| test12376(); |
| test13235(); |
| test13294(); |
| test13299(); |
| test13374(); |
| test13378(); |
| test13379(); |
| test13484(); |
| test13694(); |
| test14836(); |
| test14735(); |
| test14802(); |
| test15116(); |
| test16042(); |
| test16042b(); |
| test15243(); |
| test15653(); |
| |
| printf("Success\n"); |
| return 0; |
| } |