import core.stdc.stdio; class C { } int ctfe() { return 3; } template TypeTuple(T...) { alias T TypeTuple; } /************************************/ void showf(string f) { printf("%.*s\n", f.length, f.ptr); } /************************************/ void test1() { const int* p; const(int)* cp; cp = p; } /************************************/ void test2() { const int i = 3; const(int) j = 0; int k; // j = i; k = i; k = j; // assert(k == 3); } /************************************/ void test3() { char[3] p; const(char)[] q; q = p; } /************************************/ void test4() { char[] p; const(char)[] q; q = p; } /************************************/ void test5() { const(int**)* p; const(int)*** cp; p = cp; } /************************************/ void test6() { const(int***)[] p; const(int)***[] cp; p = cp; } /************************************/ class C8 { } void foo8(const char[] s, const C8 c, const int x) { } void test8() { auto p = &foo8; showf(p.mangleof); assert(typeof(p).mangleof == "PFxAaxC9testconst2C8xiZv"); assert(p.mangleof == "_D9testconst5test8FZ1pPFxAaxC9testconst2C8xiZv"); } /************************************/ void test9() { int [ const (char[]) ] aa; int [ char[] ] ab; int [ const char[] ] ac; aa["hello"] = 3; ab["hello"] = 3; ac["hello"] = 3; } /************************************/ void test10() { const(int) x = 3; auto y = x; //y++; assert(is(typeof(y) == const(int))); } /************************************/ void foo11(in char[] a1) { char[3] c; char[] a2 = c[]; a2[0..2] = a1; a2[0..2] = 'c'; const char b = 'b'; a2[0..2] = b; } void test11() { } /************************************/ void foo12(const char[] a1) { } void test12() { foo12("hello"); } /************************************/ immutable char[16] hexdigits1 = "0123456789ABCDE1"; immutable char[ ] hexdigits2 = "0123456789ABCDE2"; const char[16] hexdigits3 = "0123456789ABCDE3"; const char[ ] hexdigits4 = "0123456789ABCDE4"; void test13() { } /************************************/ void test14() { string s; s = s ~ "hello"; } /************************************/ class Foo15 { const string xxxx; this(immutable char[] aaa) { this.xxxx = aaa; } } void test15() { } /************************************/ void test16() { auto a = "abc"; immutable char[3] b = "abc"; const char[3] c = "abc"; } /************************************/ void test17() { const(char)[3][] a = (["abc", "def"]); assert(a[0] == "abc"); assert(a[1] == "def"); } /************************************/ class C18 { const(char)[] foo() { return "abc"; } } class D18 : C18 { override char[] foo() { return null; } } void test18() { } /************************************/ void test19() { char[] s; if (s == "abc") s = null; if (s < "abc") s = null; if (s is "abc") s = null; } /************************************/ void test20() { string p; immutable char[] q; p = p ~ q; p ~= q; } /************************************/ void test21() { string s; char[] p; p = s.dup; } /************************************/ void fill22(const(char)[] s) { } void test22() { } /************************************/ struct S23 { int x; int* p; } void foo23(const(S23) s, const(int) i) { immutable int j = 3; // j = 4; // i = 4; // s.x = 3; // *s.p = 4; } void test23() { } /************************************/ void test24() { wchar[] r; r ~= "\000"w; } /************************************/ void test25() { char* p; if (p == cast(const(char)*)"abc") {} } /************************************/ void test26() { struct S { char[3] a; } static S s = { "abc" }; } /************************************/ class C27 { int x; void foo() { x = 3; } } void test27() { C27 d = new C27; d.foo(); } /************************************/ class C28 { int x; void foo() immutable { } } void test28() { immutable(C28) d = cast(immutable)new C28; d.foo(); } /************************************/ struct S29 { } int foo29(const(S29)* s) { S29 s2; return *s == s2; } void test29() { } /************************************/ struct S30 { int x; void foo() { x = 3; } void bar() const { //x = 4; //this.x = 5; } } class C30 { int x; void foo() { x = 3; } void bar() const { //x = 4; //this.x = 5; } } void test30() { S30 s; s.foo(); s.bar(); S30 t; //t.foo(); t.bar(); C30 c = new C30; c.foo(); c.bar(); C30 d = new C30; d.foo(); d.bar(); } /************************************/ class Foo31 { int x; immutable immutable(int)* geti() { return &x; } const const(int)* getc() { return &x; } } void test31() { } /************************************/ int bar32; struct Foo32 { int func() immutable { return bar32; } } void test32() { immutable(Foo32) foo; printf("%d", foo.func()); printf("%d", foo.func()); } /************************************/ void test33() { string d = "a" ~ "b" ~ (1?"a":""); assert(d == "aba"); } /************************************/ struct S34 { int value; } const S34 s34 = { 5 }; const S34 t34 = s34; const S34 u34 = s34; void test34() { assert(u34.value == 5); } /************************************/ const int i35 = 20; template Foo35(alias bar) { } alias Foo35!(i35) foo35; void test35() { } /************************************/ immutable char[10] digits = "0123456789"; /// 0..9 immutable char[] octdigits = digits[0 .. 8]; //// 0..7 void test36() { } /************************************/ void test37() { int i = 3; const int x = i; i++; assert(x == 3); } /************************************/ void test38() { static const string s = "hello"[1..$]; assert(s == "ello"); } /************************************/ static const int x39; const int y39; static this() { x39 = 3; y39 = 4; } void test39() { const int i; assert(x39 == 3); assert(y39 == 4); const p = &x39; // assert(*p == 3); } /************************************/ struct S40 { int a; const int b = 3; // shouldn't be allocated } void test40() { assert(S40.sizeof == 8); assert(S40.init.b == 3); } /************************************/ struct S41 { int a; const int b; static const int c = ctfe() + 1; } void test41() { assert(S41.sizeof == 8); S41 s; assert(s.b == 0); assert(S41.c == 4); const(int)*p; p = &s.b; assert(*p == 0); p = &s.c; assert(*p == 4); } /************************************/ class C42 { int a = ctfe() - 2; const int b; const int c = ctfe(); static const int d; static const int e = ctfe() + 2; static this() { d = 4; } this() { b = 2; } } void test42() { printf("%d\n", C42.classinfo.initializer.length); assert(C42.classinfo.initializer.length == 12 + (void*).sizeof + (void*).sizeof); C42 c = new C42; assert(c.a == 1); assert(c.b == 2); assert(c.c == 3); assert(c.d == 4); assert(c.e == 5); const(int)*p; p = &c.b; assert(*p == 2); p = &c.c; assert(*p == 3); p = &c.d; assert(*p == 4); p = &c.e; assert(*p == 5); } /************************************/ template Foo43(T) { alias T Foo43; } void test43() { { int x; alias Foo43!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == int)); assert(is(f == int)); } { const int x; alias Foo43!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == const(int))); assert(is(f == const(int))); } { immutable int x; alias Foo43!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == immutable(int))); assert(is(f == immutable(int))); } } /************************************/ template Foo44(T:T) { alias T Foo44; } void test44() { { int x; alias Foo44!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == int)); assert(is(f == int)); } { const int x; alias Foo44!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == const(int))); assert(is(f == const(int))); } { immutable int x; alias Foo44!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == immutable(int))); assert(is(f == immutable(int))); } } /************************************/ template Foo45(T:const(T)) { alias T Foo45; } void test45() { { int x; alias Foo45!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == int)); assert(is(f == int)); } { const int x; alias Foo45!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == const(int))); assert(is(f == int)); } { immutable int x; alias Foo45!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == immutable(int))); assert(is(f == int)); } } /************************************/ template Foo46(T:immutable(T)) { alias T Foo46; } void test46() { { immutable int x; alias Foo46!(typeof(x)) f; showf(typeid(f).toString()); assert(is(typeof(x) == immutable(int))); assert(is(f == int)); } } /************************************/ template Foo47(T:T) { const int Foo47 = 2; } template Foo47(T:const(T)) { const int Foo47 = 3; } template Foo47(T:immutable(T)) { const int Foo47 = 4; } void test47() { int x2; const int x3; immutable int x4; printf("%d\n", Foo47!(typeof(x2))); printf("%d\n", Foo47!(typeof(x3))); printf("%d\n", Foo47!(typeof(x4))); assert(Foo47!(typeof(x2)) == 2); assert(Foo47!(typeof(x3)) == 3); assert(Foo47!(typeof(x4)) == 4); } /************************************/ int foo48(T)(const(T) t) { return 3; } void test48() { const int x = 4; assert(foo48(x) == 3); } /************************************/ void foo49(T)(T[] t) { showf(typeid(typeof(t)).toString()); assert(is(T == immutable(char))); } void bar49(T)(const T t) { showf(typeid(T).toString()); assert(is(T == const(int)) || is(T == immutable(int)) || is(T == int)); } void test49() { string s; foo49(s); foo49("hello"); const int c = 1; bar49(c); immutable int i = 1; bar49(i); bar49(1); } /************************************/ void foo50(T)(T t) { showf(typeid(typeof(t)).toString()); assert(is(T == C)); } void baz50(T)(T t) { showf(typeid(typeof(t)).toString()); assert(is(T == const(C))); } void bar50(T)(const T t) { showf(typeid(T).toString()); showf(typeid(typeof(t)).toString()); assert(is(T == C)); assert(is(typeof(t) == const(C))); } void abc50(T)(const T t) { showf(typeid(T).toString()); showf(typeid(typeof(t)).toString()); assert(is(T == C)); assert(is(typeof(t) == const(C))); } void test50() { C c = new C; const(C) d = new C; foo50(c); baz50(d); bar50(c); abc50(d); } /************************************/ void test51() { const(C) d = new C; //d = new C; } /************************************/ template isStaticArray(T) { const bool isStaticArray = false; } template isStaticArray(T : T[N], size_t N) { const bool isStaticArray = true; } template isDynamicArray(T, U = void) { static const isDynamicArray = false; } template isDynamicArray(T : U[], U) { static const isDynamicArray = !isStaticArray!(T); } void test52() { immutable(char[5])[int] aa = ([3:"hello", 4:"betty"]); showf(typeid(typeof(aa.values)).toString()); static assert(isDynamicArray!(typeof(aa.values))); } /************************************/ void foo53(string n) { } void read53(in string name) { foo53(name); } void test53() { read53("hello"); } /************************************/ void bar54(const(wchar)[] s) { } void test54() { const(wchar)[] fmt; bar54("Orphan format specifier: %" ~ fmt); } /************************************/ struct S55 { int foo() { return 1; } int foo() const { return 2; } int foo() immutable { return 3; } } void test55() { S55 s1; auto i = s1.foo(); assert(i == 1); const S55 s2; i = s2.foo(); assert(i == 2); immutable S55 s3; i = s3.foo(); assert(i == 3); } /************************************/ const struct S56 { int a; } void test56() { S56 s; S56 t; printf("S56.sizeof = %d\n", S56.sizeof); //t = s; } /************************************/ struct S57 { const void foo(this T)(int i) { showf(typeid(T).toString()); if (i == 1) assert(is(T == const)); if (i == 2) assert(!is(T == const)); if (i == 3) assert(is(T == immutable)); } } void test57() { const(S57) s; (&s).foo(1); S57 s2; s2.foo(2); immutable(S57) s3; s3.foo(3); } /************************************/ class C58 { const(C58) c; const C58 y; this() { y = null; c = null; } const void foo() { //c = null; // should fail } void bar() { //c = null; } } void test58() { } /************************************/ class A59 { int[] a; this() { a.length = 1; } int* ptr() { return a.ptr; } const const(int)* ptr() { return a.ptr; } immutable immutable(int)* ptr() { return a.ptr; } } void test59() { auto a = new A59; const b = cast(const)new A59; immutable c = cast(immutable)new A59; } /************************************/ int foo60(int i) { return 1; } int foo60(const int i) { return 2; } int foo60(immutable int i) { return 3; } void test60() { int i; const int j; immutable int k; assert(foo60(i) == 1); assert(foo60(j) == 2); assert(foo60(k) == 3); } /************************************/ void foo61(T)(T arg) { alias const(T) CT; assert(is(const(int) == CT)); //writeln(typeid(const(T))); //writeln(typeid(CT)); } void test61() { int x = 42; foo61(x); } /************************************/ class Foo62(T) { } void test62() { const(Foo62!(int)) f = new Foo62!(int); assert(is(typeof(f) == const(Foo62!(int)))); } /************************************/ struct S63 { int x; } void foo63(const ref S63 scheme) { //scheme.x = 3; } void test63() { S63 scheme; foo63(scheme); } /************************************/ struct S64 { int a; long b; } void test64() { S64 s1 = S64(2,3); const s2 = S64(2,3); immutable S64 s3 = S64(2,3); s1 = s1; s1 = s2; s1 = s3; } /************************************/ struct S65 { int a; long b; char *p; } void test65() { char c; S65 s1 = S65(2,3); const s2 = S65(2,3); immutable S65 s3 = S65(2,3); S65 t1 = S65(2,3,null); const t2 = S65(2,3,null); immutable S65 t3 = S65(2,3,null); } /************************************/ struct S66 { int a; long b; } void test66() { char c; S66 s1 = S66(2,3); const s2 = S66(2,3); immutable S66 s3 = S66(2,3); S66 t1 = s1; S66 t2 = s2; S66 t3 = s3; const(S66) u1 = s1; const(S66) u2 = s2; const(S66) u3 = s3; immutable(S66) v1 = s1; immutable(S66) v2 = s2; immutable(S66) v3 = s3; } /************************************/ struct Foo68 { int z; immutable int x; int y; } void test68() { Foo68 bar; bar.y = 2; } /************************************/ class C69 {} struct S69 {} void test69() { immutable(S69)* si; S69* sm; bool a = si is sm; immutable(C69) ci; const(C69) cm; bool b = ci is cm; } /************************************/ struct S70 { int i; } void test70() { S70 s; const(S70) cs = s; S70 s1 = cs; S70 s2 = cast(S70)cs; } /************************************/ void test72() { int a; const int b; enum { int c = 0 } immutable int d = 0; assert(__traits(isSame, a, a)); assert(__traits(isSame, b, b)); assert(__traits(isSame, c, c)); assert(__traits(isSame, d, d)); } /************************************/ void a73(const int [] data...) { a73(1); } void test73() { } /************************************/ struct S74 { int x; } const S74 s_const = {0}; S74 s_mutable = s_const; void test74() { } /************************************/ struct A75 { int x; } struct B75 { A75 s1; } const A75 s1_const = {0}; const B75 s2_const = {s1_const}; void test75() { } /************************************/ void test76() { int[int] array; const(int[int]) a = array; } /************************************/ void test77() { int[][] intArrayArray; int[][][] intArrayArrayArray; // const(int)[][] f1 = intArrayArray; const(int[])[] f2 = intArrayArray; // const(int)[][][] g1 = intArrayArrayArray; // const(int[])[][] g2 = intArrayArrayArray; const(int[][])[] g3 = intArrayArrayArray; } /************************************/ void foo78(T)(const(T)[] arg1, const(T)[] arg2) { } void test78() { foo78("hello", "world".dup); foo78("hello", "world"); foo78("hello".dup, "world".dup); foo78(cast(const)"hello", cast(const)"world"); } /************************************/ const bool[string] stopWords79; static this() { stopWords79 = [ "a"[]:1 ]; } void test79() { "abc" in stopWords79; } /************************************/ void test80(inout(int) _ = 0) { char x; inout(char) y = x; const(char)[] c; immutable(char)[] i; shared(char)[] s; const(shared(char))[] sc; inout(char)[] w; inout(shared(char))[] sw; c = c; c = i; static assert(!__traits(compiles, c = s)); static assert(!__traits(compiles, c = sc)); c = w; static assert(!__traits(compiles, c = sw)); static assert(!__traits(compiles, i = c)); i = i; static assert(!__traits(compiles, i = s)); static assert(!__traits(compiles, i = sc)); static assert(!__traits(compiles, i = w)); static assert(!__traits(compiles, i = sw)); static assert(!__traits(compiles, s = c)); static assert(!__traits(compiles, s = i)); s = s; static assert(!__traits(compiles, s = sc)); static assert(!__traits(compiles, s = w)); static assert(!__traits(compiles, s = sw)); static assert(!__traits(compiles, sc = c)); sc = i; sc = s; sc = sc; static assert(!__traits(compiles, sc = w)); sc = sw; static assert(!__traits(compiles, w = c)); static assert(!__traits(compiles, w = i)); static assert(!__traits(compiles, w = s)); static assert(!__traits(compiles, w = sc)); w = w; static assert(!__traits(compiles, w = sw)); static assert(!__traits(compiles, sw = c)); static assert(!__traits(compiles, sw = i)); static assert(!__traits(compiles, sw = s)); static assert(!__traits(compiles, sw = sc)); static assert(!__traits(compiles, sw = w)); sw = sw; } /************************************/ void test81(inout(int) _ = 0) { const(char)* c; immutable(char)* i; shared(char)* s; const(shared(char))* sc; inout(char)* w; c = c; c = i; static assert(!__traits(compiles, c = s)); static assert(!__traits(compiles, c = sc)); c = w; static assert(!__traits(compiles, i = c)); i = i; static assert(!__traits(compiles, i = s)); static assert(!__traits(compiles, i = sc)); static assert(!__traits(compiles, i = w)); static assert(!__traits(compiles, s = c)); static assert(!__traits(compiles, s = i)); s = s; static assert(!__traits(compiles, s = sc)); static assert(!__traits(compiles, s = w)); static assert(!__traits(compiles, sc = c)); sc = i; sc = s; sc = sc; static assert(!__traits(compiles, sc = w)); static assert(!__traits(compiles, w = c)); static assert(!__traits(compiles, w = i)); static assert(!__traits(compiles, w = s)); static assert(!__traits(compiles, w = sc)); w = w; } /************************************/ void test82(inout(int) _ = 0) { const(immutable(char)*) c; pragma(msg, typeof(c)); static assert(typeof(c).stringof == "const(immutable(char)*)"); inout(immutable(char)*) d; pragma(msg, typeof(d)); static assert(typeof(d).stringof == "inout(immutable(char)*)"); inout(const(char)*) e; pragma(msg, typeof(e)); static assert(is(typeof(e) == inout(const(char)*))); static assert(typeof(e).stringof == "inout(const(char)*)"); pragma(msg, typeof(*e)); static assert(is(typeof(*e) == inout(const(char)))); static assert(typeof(*e).stringof == "inout(const(char))"); inout const(char)* f; static assert(is(typeof(e) == typeof(f))); inout(shared(char)) g; pragma(msg, typeof(g)); static assert(typeof(g).stringof == "shared(inout(char))"); shared(inout(char)) h; pragma(msg, typeof(h)); static assert(typeof(h).stringof == "shared(inout(char))"); inout(immutable(char)) i; pragma(msg, typeof(i)); static assert(typeof(i).stringof == "immutable(char)"); immutable(inout(char)) j; pragma(msg, typeof(j)); static assert(typeof(j).stringof == "immutable(char)"); inout(const(char)) k; pragma(msg, typeof(k)); static assert(typeof(k).stringof == "inout(const(char))"); const(inout(char)) l; pragma(msg, typeof(l)); static assert(typeof(l).stringof == "inout(const(char))"); shared(const(char)) m; pragma(msg, typeof(m)); static assert(typeof(m).stringof == "shared(const(char))"); const(shared(char)) n; pragma(msg, typeof(n)); static assert(typeof(n).stringof == "shared(const(char))"); inout(char*****) o; pragma(msg, typeof(o)); static assert(typeof(o).stringof == "inout(char*****)"); pragma(msg, typeof(cast()o)); static assert(typeof(cast()o).stringof == "inout(char****)*"); const(char*****) p; pragma(msg, typeof(p)); static assert(typeof(p).stringof == "const(char*****)"); pragma(msg, typeof(cast()p)); static assert(typeof(cast()p).stringof == "const(char****)*"); immutable(char*****) q; pragma(msg, typeof(q)); static assert(typeof(q).stringof == "immutable(char*****)"); pragma(msg, typeof(cast()q)); static assert(typeof(cast()q).stringof == "immutable(char****)*"); shared(char*****) r; pragma(msg, typeof(r)); static assert(typeof(r).stringof == "shared(char*****)"); pragma(msg, typeof(cast()r)); static assert(typeof(cast()r).stringof == "shared(char****)*"); pragma(msg, typeof(cast(const)r)); static assert(typeof(cast(const)r).stringof == "const(shared(char****)*)"); pragma(msg, typeof(cast(const shared)r)); static assert(typeof(cast(const shared)r).stringof == "shared(const(char*****))"); pragma(msg, typeof(cast(shared)r)); static assert(typeof(cast(shared)r).stringof == "shared(char*****)"); pragma(msg, typeof(cast(immutable)r)); static assert(typeof(cast(immutable)r).stringof == "immutable(char*****)"); pragma(msg, typeof(cast(inout)r)); static assert(typeof(cast(inout)r).stringof == "inout(shared(char****)*)"); inout(shared(char**)***) s; pragma(msg, typeof(s)); static assert(typeof(s).stringof == "inout(shared(char**)***)"); pragma(msg, typeof(***s)); static assert(typeof(***s).stringof == "shared(inout(char**))"); } /************************************/ void test83(inout(int) _ = 0) { static assert( __traits(compiles, typeid(int* function(inout int)))); static assert( __traits(compiles, typeid(int* delegate(inout int)))); static assert(!__traits(compiles, typeid(inout(int*) function(int)))); static assert(!__traits(compiles, typeid(inout(int*) delegate(int)))); static assert(!__traits(compiles, typeid(inout(int*) function()))); static assert(!__traits(compiles, typeid(inout(int*) delegate()))); inout(int*) function(inout(int)) fp; inout(int*) delegate(inout(int)) dg; } /************************************/ inout(char[]) foo84(inout char[] s) { return s; } void test84() { char[] m; const(char)[] c; string s; auto r = foo84(s); pragma(msg, typeof(r).stringof); static assert(typeof(r).stringof == "immutable(string)"); pragma(msg, typeof(foo84(c)).stringof); static assert(typeof(foo84(c)).stringof == "const(char[])"); pragma(msg, typeof(foo84(m)).stringof); static assert(typeof(foo84(m)).stringof == "char[]"); } /************************************/ class foo85 { } alias shared foo85 Y85; void test85() { pragma(msg, Y85); shared(foo85) x = new Y85; } /************************************/ struct foo87 { int bar(T)(T t){ return 1; } int bar(T)(T t) shared { return 2; } } void test87() { foo87 x; auto i = x.bar(1); assert(i == 1); shared foo87 y; i = y.bar(1); assert(i == 2); } /************************************/ // 2751 void test88(immutable(int[3]) a) { const(char)[26] abc1 = "abcdefghijklmnopqrstuvwxyz"; const(char[26]) abc2 = "abcdefghijklmnopqrstuvwxyz"; immutable(const(char)[26]) abc3 = "abcdefghijklmnopqrstuvwxyz"; const(immutable(char)[26]) abc4 = "abcdefghijklmnopqrstuvwxyz"; auto abc5 = cast()"abcdefghijklmnopqrstuvwxyz"; pragma(msg, typeof(abc1).stringof); pragma(msg, typeof(abc2).stringof); pragma(msg, typeof(abc3).stringof); pragma(msg, typeof(abc4).stringof); pragma(msg, typeof(abc5).stringof); static assert(is(typeof(abc1) == typeof(abc2))); static assert(is(typeof(abc1) == const(char[26]))); static assert(is(typeof(abc3) == typeof(abc4))); static assert(is(typeof(abc3) == immutable(char[26]))); auto b = cast()a; pragma(msg, typeof(b).stringof); static assert(is(typeof(b) == int[3])); } /************************************/ // 3748 // version = error8; // version = error11; class C3748 { private int _x; this(int x) { this._x = x; } @property inout(int)* xptr() inout { return &_x; } @property void x(int newval) { _x = newval; } } struct S3748 { int x; immutable int y = 5; const int z = 6; C3748 c; inout(int)* getX() inout { static assert(!__traits(compiles, { x = 4; })); return &x; } inout(int)* getCX(C3748 otherc) inout { inout(C3748) c2 = c; // typeof(c) == inout(C3748) static assert(!__traits(compiles, { inout(C3748) err2 = new C3748(1); })); static assert(!__traits(compiles, { inout(C3748) err3 = otherc; })); auto v1 = getLowestXptr(c, otherc); static assert(is(typeof(v1) == const(int)*)); auto v2 = getLowestXptr(c, c); static assert(is(typeof(v2) == inout(int)*)); alias typeof(return) R; static assert(!__traits(compiles, { c.x = 4; })); static assert(!__traits(compiles, { R r = otherc.xptr; })); static assert(!__traits(compiles, { R r = &y; })); static assert(!__traits(compiles, { R r = &z; })); return c2.xptr; } version(error8) inout(int) err8; // see fail_compilation/failinout3748a.d } inout(int)* getLowestXptr(inout(C3748) c1, inout(C3748) c2) { inout(int)* x1 = c1.xptr; inout(int)* x2 = c2.xptr; if(*x1 <= *x2) return x1; return x2; } ref inout(int) getXRef(inout(C3748) c1, inout(C3748) c2) { return *getLowestXptr(c1, c2); } void test3748() { S3748 s; s.c = new C3748(1); const(S3748)* sp = &s; auto s2 = new S3748; s2.x = 3; s2.c = new C3748(2); auto s3 = cast(immutable(S3748)*) s2; auto v1 = s.getX; static assert(is(typeof(v1) == int*)); auto v2 = sp.getX; static assert(is(typeof(v2) == const(int)*)); auto v3 = s3.getX; static assert(is(typeof(v3) == immutable(int)*)); static assert(!__traits(compiles, { int *err9 = sp.getX; })); static assert(!__traits(compiles, { int *err10 = s3.getX; })); version(error11) inout(int)* err11; // see fail_compilation/failinout3748b.d auto v4 = getLowestXptr(s.c, s3.c); static assert(is(typeof(v4) == const(int)*)); auto v5 = getLowestXptr(s.c, s.c); static assert(is(typeof(v5) == int*)); auto v6 = getLowestXptr(s3.c, s3.c); static assert(is(typeof(v6) == immutable(int)*)); getXRef(s.c, s.c) = 3; } /************************************/ void test3748a(inout int = 1) { int[] ma; inout(int[]) wa; const(int[]) ca; immutable(int[]) ia; shared(int[]) sa; shared(inout(int[])) swa; shared(const(int[])) sca; static foo1(E)(inout(E[]) a) { return E.init; } static assert( is( typeof(foo1( ma)) == int)); static assert( is( typeof(foo1( wa)) == int)); static assert( is( typeof(foo1( ca)) == int)); static assert( is( typeof(foo1( ia)) == int)); static assert( is( typeof(foo1( sa)) == shared int)); static assert( is( typeof(foo1(swa)) == shared int)); static assert( is( typeof(foo1(sca)) == shared int)); static foo2(E)(shared inout(E[]) a) { return E.init; } static assert(!is( typeof(foo2( ma)) )); static assert(!is( typeof(foo2( wa)) )); static assert(!is( typeof(foo2( ca)) )); static assert( is( typeof(foo2( ia)) == int)); static assert( is( typeof(foo2( sa)) == int)); static assert( is( typeof(foo2(swa)) == int)); static assert( is( typeof(foo2(sca)) == int)); } void test3748b(inout int = 1) { // Top of the parameter type is non-ref & qualified static inout(int[]) foo1( inout(int[]) a); static shared(inout(int[])) bar1(shared(inout(int[])) a); // Top of the parameter type is non-ref & un-qualified static inout(int) [] foo2( inout(int) [] a); static shared(inout(int))[] bar2(shared(inout(int))[] a); // Top of the argument type is qualified int[] ma1; inout(int[]) wa1; const(int[]) ca1; shared(int[]) sa1; shared(inout(int[])) swa1; shared(const(int[])) sca1; immutable(int[]) ia1; // Top of the argument type is un-qualified int [] ma2; inout(int) [] wa2; const(int) [] ca2; shared(int) [] sa2; shared(inout(int))[] swa2; shared(const(int))[] sca2; immutable(int) [] ia2; // --> non-ref qualified param VS qualified arg static assert( is( typeof(foo1( ma1)) == typeof( ma1) )); static assert( is( typeof(foo1( wa1)) == typeof( wa1) )); static assert( is( typeof(foo1( ca1)) == typeof( ca1) )); static assert( is( typeof(bar1( sa1)) == typeof( sa1) )); static assert( is( typeof(bar1(swa1)) == typeof(swa1) )); static assert( is( typeof(bar1(sca1)) == typeof(sca1) )); static assert( is( typeof(foo1( ia1)) == typeof( ia1) )); // --> non-ref un-qualified param VS qualified arg static assert( is( typeof(foo2( ma1)) == typeof( ma2) )); static assert( is( typeof(foo2( wa1)) == typeof( wa2) )); static assert( is( typeof(foo2( ca1)) == typeof( ca2) )); static assert( is( typeof(bar2( sa1)) == typeof( sa2) )); static assert( is( typeof(bar2(swa1)) == typeof(swa2) )); static assert( is( typeof(bar2(sca1)) == typeof(sca2) )); static assert( is( typeof(foo2( ia1)) == typeof( ia2) )); // --> non-ref qualified param VS un-qualified arg static assert( is( typeof(foo1( ma2)) == typeof( ma1) )); static assert( is( typeof(foo1( wa2)) )); static assert( is( typeof(foo1( ca2)) )); static assert( is( typeof(bar1( sa2)) == typeof( sa1) )); static assert( is( typeof(bar1(swa2)) )); static assert( is( typeof(bar1(sca2)) )); static assert( is( typeof(foo1( ia2)) )); // --> non-ref un-qualified param VS un-qualified arg static assert( is( typeof(foo2( ma2)) == typeof( ma2) )); static assert( is( typeof(foo2( wa2)) == typeof( wa2) )); static assert( is( typeof(foo2( ca2)) == typeof( ca2) )); static assert( is( typeof(bar2( sa2)) == typeof( sa2) )); static assert( is( typeof(bar2(swa2)) == typeof(swa2) )); static assert( is( typeof(bar2(sca2)) == typeof(sca2) )); static assert( is( typeof(foo2( ia2)) == typeof( ia2) )); } void test3748c(inout int = 1) { // Top of the parameter type is ref & qualified static inout(int[]) foo1(ref inout(int[]) a); static shared(inout(int[])) bar1(ref shared(inout(int[])) a); // Top of the parameter type is ref & un-qualified static inout(int) [] foo2(ref inout(int) [] a); static shared(inout(int))[] bar2(ref shared(inout(int))[] a); // Top of the argument type is qualified int[] ma1; inout(int[]) wa1; const(int[]) ca1; shared(int[]) sa1; shared(inout(int[])) swa1; shared(const(int[])) sca1; immutable(int[]) ia1; // Top of the argument type is un-qualified int [] ma2; inout(int) [] wa2; const(int) [] ca2; shared(int) [] sa2; shared(inout(int))[] swa2; shared(const(int))[] sca2; immutable(int) [] ia2; // --> ref qualified param VS qualified arg static assert( is( typeof(foo1( ma1)) == typeof( ma1) )); static assert( is( typeof(foo1( wa1)) == typeof( wa1) )); static assert( is( typeof(foo1( ca1)) == typeof( ca1) )); static assert( is( typeof(bar1( sa1)) == typeof( sa1) )); static assert( is( typeof(bar1(swa1)) == typeof(swa1) )); static assert( is( typeof(bar1(sca1)) == typeof(sca1) )); static assert( is( typeof(foo1( ia1)) == typeof( ia1) )); // --> ref un-qualified param VS qualified arg static assert( is( typeof(foo2( ma1)) == typeof( ma2) )); static assert(!is( typeof(foo2( wa1)) )); static assert(!is( typeof(foo2( ca1)) )); static assert(!is( typeof(bar2( sa1)) )); static assert(!is( typeof(bar2(swa1)) )); static assert(!is( typeof(bar2(sca1)) )); static assert(!is( typeof(foo2( ia1)) )); // --> ref qualified param VS un-qualified arg static assert( is( typeof(foo1( ma2)) == typeof( ma1) )); static assert(!is( typeof(foo1( wa2)) )); static assert(!is( typeof(foo1( ca2)) )); // why this is OK? --> [*] static assert(!is( typeof(bar1( sa2)) )); static assert(!is( typeof(bar1(swa2)) )); static assert(!is( typeof(bar1(sca2)) )); static assert(!is( typeof(foo1( ia2)) )); // --> ref un-qualified param VS un-qualified arg static assert( is( typeof(foo2( ma2)) == typeof( ma2) )); static assert( is( typeof(foo2( wa2)) == typeof( wa2) )); static assert( is( typeof(foo2( ca2)) == typeof( ca2) )); static assert( is( typeof(bar2( sa2)) == typeof( sa2) )); static assert( is( typeof(bar2(swa2)) == typeof(swa2) )); static assert( is( typeof(bar2(sca2)) == typeof(sca2) )); static assert( is( typeof(foo2( ia2)) == typeof( ia2) )); } /************************************/ // 4968 void test4968() { inout(int) f1(inout(int) i) { return i; } int mi; const int ci; immutable int ii; static assert(is(typeof(f1(mi)) == int)); static assert(is(typeof(f1(ci)) == const(int))); static assert(is(typeof(f1(ii)) == immutable(int))); inout(int)* f2(inout(int)* p) { return p; } int* mp; const(int)* cp; immutable(int)* ip; static assert(is(typeof(f2(mp)) == int*)); static assert(is(typeof(f2(cp)) == const(int)*)); static assert(is(typeof(f2(ip)) == immutable(int)*)); inout(int)[] f3(inout(int)[] a) { return a; } int[] ma; const(int)[] ca; immutable(int)[] ia; static assert(is(typeof(f3(ma)) == int[])); static assert(is(typeof(f3(ca)) == const(int)[])); static assert(is(typeof(f3(ia)) == immutable(int)[])); inout(int)[1] f4(inout(int)[1] sa) { return sa; } int[1] msa; const int[1] csa; immutable int[1] isa; static assert(is(typeof(f4(msa)) == int[1])); static assert(is(typeof(f4(csa)) == const(int)[1])); static assert(is(typeof(f4(isa)) == immutable(int)[1])); inout(int)[string] f5(inout(int)[string] aa) { return aa; } int[string] maa; const(int)[string] caa; immutable(int)[string] iaa; static assert(is(typeof(f5(maa)) == int[string])); static assert(is(typeof(f5(caa)) == const(int)[string])); static assert(is(typeof(f5(iaa)) == immutable(int)[string])); } /************************************/ // 1961 inout(char)[] strstr(inout(char)[] source, const(char)[] pattern) { /* * this would be an error, as const(char)[] is not implicitly castable to * inout(char)[] */ // return pattern; for(int i = 0; i + pattern.length <= source.length; i++) { inout(char)[] tmp = source[i..pattern.length]; // ok if (tmp == pattern) // ok, tmp implicitly casts to const(char)[] return source[i..$]; // implicitly casts back to call-site source } return source[$..$]; // to be consistent with strstr. } void test1961a() { auto a = "hello"; a = strstr(a, "llo"); // cf (constancy factor) == immutable static assert(!__traits(compiles, { char[] b = strstr(a, "llo"); })); // error, cannot cast immutable to mutable char[] b = "hello".dup; b = strstr(b, "llo"); // cf == mutable (note that "llo" doesn't play a role // because that parameter is not inout) const(char)[] c = strstr(b, "llo"); // cf = mutable, ok because mutable // implicitly casts to const c = strstr(a, "llo"); // cf = immutable, ok immutable casts to const } inout(T) min(T)(inout(T) a, inout(T) b) { return a < b ? a : b; } void test1961b() { immutable(char)[] i = "hello"; const(char)[] c = "there"; char[] m = "Walter".dup; static assert(!__traits(compiles, { i = min(i, c); })); // error, since i and c vary in constancy, the result // is const, and you cannot implicitly cast const to immutable. c = min(i, c); // ok, cf == const, because not homogeneous c = min(m, c); // ok, cf == const c = min(m, i); // ok, cf == const i = min(i, "blah"); // ok, cf == immutable, homogeneous static assert(!__traits(compiles, { m = min(m, c); })); // error, cf == const because not homogeneous. static assert(!__traits(compiles, { m = min(m, "blah"); })); // error, cf == const m = min(m, "blah".dup); // ok } inout(T) min2(int i, int j, T)(inout(T) a, inout(T) b) { //pragma(msg, "(", i, ", ", j, ") = ", T); static assert(is(T == char[])); return a < b ? a : b; } template seq(T...){ alias T seq; } void test1961c() { immutable(char[]) iia = "hello1"; immutable(char)[] ima = "hello2"; const(char[]) cca = "there1"; const(char)[] cma = "there2"; char[] mma = "Walter".dup; foreach (i, x; seq!(iia, ima, cca, cma, mma)) foreach (j, y; seq!(iia, ima, cca, cma, mma)) { min2!(i, j)(x, y); //pragma(msg, "x: ",typeof(x), ", y: ",typeof(y), " -> ", typeof(min2(x, y)), " : ", __traits(compiles, min2(x, y))); } } /************************************/ inout(int) function(inout(int)) notinoutfun1() { return null; } inout(int) function(inout(int))[] notinoutfun2() { return null; } inout(int) delegate(inout(int)) notinoutfun3() { return null; } inout(int) delegate(inout(int))[] notinoutfun4() { return null; } void notinoutfun1(inout(int) function(inout(int)) fn) {} void notinoutfun2(inout(int) function(inout(int))[] fn) {} void notinoutfun3(inout(int) delegate(inout(int)) dg) {} void notinoutfun4(inout(int) delegate(inout(int))[] dg) {} void test88() { inout(int) function(inout int) fp; inout(int) delegate(inout int) dg; inout(int) function(inout int)* fp2p; inout(int) function(inout int)[] fp2a; inout(int) function(inout int)[3] fp2s; inout(int) delegate(inout int)* dg3p; inout(int) delegate(inout int)[] dg3a; inout(int) delegate(inout int)[3] dg3s; int delegate() inout* dg4p; int delegate() inout[] dg4a; int delegate() inout[3] dg4s; static assert(!__traits(compiles, { inout(int)* p; })); static assert(!__traits(compiles, { inout(int delegate()) dg; })); } /************************************/ // 4251 void test4251a() { alias int T; static assert(!is( immutable(T)** : const(T)** )); // NG, tail difference static assert( is( immutable(T)** : const(T**) )); // OK, tail to const static assert( is( T *** : T *** )); // OK, tail is same static assert(!is( T *** : const(T)*** )); static assert(!is( T *** : const(T*)** )); static assert( is( T *** : const(T**)* )); // OK, tail to const static assert( is( T *** : const(T***) )); // OK, tail to const static assert(!is( T *** : immutable(T)*** )); static assert(!is( T *** : immutable(T*)** )); static assert(!is( T *** : immutable(T**)* )); static assert(!is( T *** : immutable(T***) )); static assert(!is( const(T)*** : T *** )); static assert( is( const(T)*** : const(T)*** )); // OK, tail is same static assert(!is( const(T)*** : const(T*)** )); static assert( is( const(T)*** : const(T**)* )); // OK, tail to const static assert( is( const(T)*** : const(T***) )); // OK, tail to const static assert(!is( const(T)*** : immutable(T)*** )); static assert(!is( const(T)*** : immutable(T*)** )); static assert(!is( const(T)*** : immutable(T**)* )); static assert(!is( const(T)*** : immutable(T***) )); static assert(!is( const(T*)** : T *** )); static assert(!is( const(T*)** : const(T)*** )); static assert( is( const(T*)** : const(T*)** )); // OK, tail is same static assert( is( const(T*)** : const(T**)* )); // OK, tail to const static assert( is( const(T*)** : const(T***) )); // OK, tail to const static assert(!is( const(T*)** : immutable(T)*** )); static assert(!is( const(T*)** : immutable(T*)** )); static assert(!is( const(T*)** : immutable(T**)* )); static assert(!is( const(T*)** : immutable(T***) )); static assert(!is( const(T**)* : T *** )); static assert(!is( const(T**)* : const(T)*** )); static assert(!is( const(T**)* : const(T*)** )); static assert( is( const(T**)* : const(T**)* )); // OK, tail is same static assert( is( const(T**)* : const(T***) )); // OK, tail is same static assert(!is( const(T**)* : immutable(T)*** )); static assert(!is( const(T**)* : immutable(T*)** )); static assert(!is( const(T**)* : immutable(T**)* )); static assert(!is( const(T**)* : immutable(T***) )); static assert(!is( const(T***) : T *** )); static assert(!is( const(T***) : const(T)*** )); static assert(!is( const(T***) : const(T*)** )); static assert( is( const(T***) : const(T**)* )); // OK, tail is same static assert( is( const(T***) : const(T***) )); // OK, tail is same static assert(!is( const(T***) : T *** )); static assert(!is( const(T***) : immutable(T)*** )); static assert(!is( const(T***) : immutable(T*)** )); static assert(!is( const(T***) : immutable(T**)* )); static assert(!is( const(T***) : immutable(T***) )); static assert(!is( immutable(T)*** : T *** )); static assert(!is( immutable(T)*** : const(T)*** )); static assert(!is( immutable(T)*** : const(T*)** )); static assert( is( immutable(T)*** : const(T**)* )); // OK, tail to const static assert( is( immutable(T)*** : const(T***) )); // OK, tail to const static assert( is( immutable(T)*** : immutable(T)*** )); // OK, tail is same static assert(!is( immutable(T)*** : immutable(T*)** )); static assert(!is( immutable(T)*** : immutable(T**)* )); static assert(!is( immutable(T)*** : immutable(T***) )); static assert(!is( immutable(T*)** : T *** )); static assert(!is( immutable(T*)** : const(T)*** )); static assert(!is( immutable(T*)** : const(T*)** )); static assert( is( immutable(T*)** : const(T**)* )); // OK, tail to const static assert( is( immutable(T*)** : const(T***) )); // OK, tail to const static assert(!is( immutable(T*)** : immutable(T)*** )); static assert( is( immutable(T*)** : immutable(T*)** )); // OK, tail is same static assert(!is( immutable(T*)** : immutable(T**)* )); static assert(!is( immutable(T*)** : immutable(T***) )); static assert(!is( immutable(T**)* : T *** )); static assert(!is( immutable(T**)* : const(T)*** )); static assert(!is( immutable(T**)* : const(T*)** )); static assert( is( immutable(T**)* : const(T**)* )); // OK, tail to const static assert( is( immutable(T**)* : const(T***) )); // OK, tail to const static assert(!is( immutable(T**)* : immutable(T)*** )); static assert(!is( immutable(T**)* : immutable(T*)** )); static assert( is( immutable(T**)* : immutable(T**)* )); // OK, tail is same static assert( is( immutable(T**)* : immutable(T***) )); // OK, tail is same static assert(!is( immutable(T***) : T *** )); static assert(!is( immutable(T***) : const(T)*** )); static assert(!is( immutable(T***) : const(T*)** )); static assert( is( immutable(T***) : const(T**)* )); // OK, tail to const static assert( is( immutable(T***) : const(T***) )); // OK, tail to const static assert(!is( immutable(T***) : immutable(T)*** )); static assert(!is( immutable(T***) : immutable(T*)** )); static assert( is( immutable(T***) : immutable(T**)* )); // OK, tail is same static assert( is( immutable(T***) : immutable(T***) )); // OK, tail is same static assert( is( immutable(int)** : const(immutable(int)*)* )); // OK, tail to const // shared level should be same static assert(!is( shared(T)*** : const(T***) )); // NG, tail to const but shared level is different static assert( is( shared(T***) : shared(const(T***)) )); // OK, tail to const and shared level is same // head qualifier difference is ignored static assert(is( shared(int)* : shared(int*) )); static assert(is( inout (int)* : inout (int*) )); // static assert(!is( T** : T*** )); static assert(!is( T[]** : T*** )); } void test4251b() { class C {} class D : C {} static assert(!is( C[]* : const(C)[]* )); static assert( is( C[]* : const(C[])* )); // derived class to const(base class) in tail static assert( is( D[] : const(C)[] )); static assert( is( D[]* : const(C[])* )); static assert( is( D* : const(C)* )); static assert( is( D** : const(C*)* )); // derived class to const(base interface) in tail interface I {} class X : I {} static assert(!is( X[] : const(I)[] )); // interface to const(base interface) in tail interface J {} interface K : I, J {} static assert( is( K[] : const(I)[] )); // OK, runtime offset is same static assert(!is( K[] : const(J)[] )); // NG, runtime offset is different } /************************************/ // 5473 void test5473() { class C { int b; void f(){} static int x; static void g(){}; } struct S { int b; void f(){} static int x; static void g(){}; } void dummy(); alias typeof(dummy) VoidFunc; const C c = new C; const S s; foreach (a; TypeTuple!(c, s)) { alias typeof(a) A; static assert(is(typeof(a.b) == const int)); // const(int) static assert(is(typeof(a.f) == VoidFunc)); static assert(is(typeof(a.x) == int)); static assert(is(typeof(a.g) == VoidFunc)); static assert(is(typeof((const A).b) == const int)); // int, should be const(int) static assert(is(typeof((const A).f) == VoidFunc)); static assert(is(typeof((const A).x) == int)); static assert(is(typeof((const A).g) == VoidFunc)); } } /************************************/ // 5493 void test5493() { // non template function void pifun(immutable(char)[]* a) {} void rifun(ref immutable(char)[] a) {} void pcfun(const(char)[]* a) {} void rcfun(ref const(char)[] a) {} immutable char[] buf1 = "hello"; static assert(!__traits(compiles, pifun(buf1))); static assert(!__traits(compiles, pcfun(buf1))); static assert(!__traits(compiles, rifun(buf1))); static assert(!__traits(compiles, rcfun(buf1))); immutable char[5] buf2 = "hello"; static assert(!__traits(compiles, pifun(buf2))); static assert(!__traits(compiles, pcfun(buf2))); static assert(!__traits(compiles, rifun(buf2))); static assert(!__traits(compiles, rcfun(buf2))); const char[] buf3 = "hello"; static assert(!__traits(compiles, pcfun(buf3))); static assert(!__traits(compiles, rcfun(buf3))); const char[5] buf4 = "hello"; static assert(!__traits(compiles, pcfun(buf4))); static assert(!__traits(compiles, rcfun(buf4))); // template function void pmesswith(T)(const(T)[]* ts, const(T) t) { *ts ~= t; } void rmesswith(T)(ref const(T)[] ts, const(T) t) { ts ~= t; } class C { int x; this(int i) immutable { x = i; } } C[] cs; immutable C ci = new immutable(C)(6); assert (ci.x == 6); static assert(!__traits(compiles, pmesswith(&cs,ci))); static assert(!__traits(compiles, rmesswith(cs,ci))); //cs[$-1].x = 14; //assert (ci.x == 14); //whoops. } /************************************/ // 5493 + inout void test5493inout() { int m; const(int) c; immutable(int) i; inout(int) ptrfoo(inout(int)** a, inout(int)* b) { *a = b; return 0; // dummy } inout(int) reffoo(ref inout(int)* a, inout(int)* b) { a = b; return 0; // dummy } // wild matching: inout == mutable int* pm; ptrfoo(&pm, &m); assert(pm == &m); static assert(!__traits(compiles, ptrfoo(&pm, &c))); static assert(!__traits(compiles, ptrfoo(&pm, &i))); reffoo( pm, &m); assert(pm == &m); static assert(!__traits(compiles, reffoo( pm, &c))); static assert(!__traits(compiles, reffoo( pm, &i))); // wild matching: inout == const const(int)* pc; ptrfoo(&pc, &m); assert(pc == &m); ptrfoo(&pc, &c); assert(pc == &c); ptrfoo(&pc, &i); assert(pc == &i); reffoo( pc, &m); assert(pc == &m); reffoo( pc, &c); assert(pc == &c); reffoo( pc, &i); assert(pc == &i); // wild matching: inout == immutable immutable(int)* pi; static assert(!__traits(compiles, ptrfoo(&pi, &m))); static assert(!__traits(compiles, ptrfoo(&pi, &c))); ptrfoo(&pi, &i); assert(pi == &i); static assert(!__traits(compiles, reffoo( pi, &m))); static assert(!__traits(compiles, reffoo( pi, &c))); reffoo( pi, &i); assert(pi == &i); } /************************************/ // 6782 struct Tuple6782(T...) { T field; alias field this; } auto tuple6782(T...)(T field) { return Tuple6782!T(field); } struct Range6782a { int *ptr; @property inout(int)* front() inout { return ptr; } @property bool empty() const { return ptr is null; } void popFront() { ptr = null; } } struct Range6782b { Tuple6782!(int, int*) e; @property front() inout { return e; } @property empty() const { return e[1] is null; } void popFront() { e[1] = null; } } void test6782() { int x = 5; auto r1 = Range6782a(&x); foreach(p; r1) {} auto r2 = Range6782b(tuple6782(1, &x)); foreach(i, p; r2) {} } /************************************/ // 6864 int fn6864( const int n) { return 1; } int fn6864(shared int n) { return 2; } inout(int) fw6864(inout int s) { return 1; } inout(int) fw6864(shared inout int s) { return 2; } void test6864() { int n; assert(fn6864(n) == 1); assert(fw6864(n) == 1); shared int sn; assert(fn6864(sn) == 2); assert(fw6864(sn) == 2); } /************************************/ // 6865 shared(inout(int)) foo6865(shared(inout(int)) n){ return n; } void test6865() { shared(const(int)) n; static assert(is(typeof(foo6865(n)) == shared(const(int)))); } /************************************/ // 6866 struct S6866 { const(char)[] val; alias val this; } inout(char)[] foo6866(inout(char)[] s) { return s; } void test6866() { S6866 s; static assert(is(typeof(foo6866(s)) == const(char)[])); // Assertion failure: 'targ' on line 2029 in file 'mtype.c' } /************************************/ // 6867 inout(char)[] test6867(inout(char)[] a) { foreach(dchar d; a) // No error if 'dchar' is removed { foreach(c; a) // line 5 { } } return []; } /************************************/ // 6870 void test6870() { shared(int) x; static assert(is(typeof(x) == shared(int))); // pass const(typeof(x)) y; const(shared(int)) z; static assert(is(typeof(y) == typeof(z))); // fail! } /************************************/ // 6338, 6922 alias int T; static assert(is( immutable( T ) == immutable(T) )); static assert(is( immutable( const(T)) == immutable(T) )); // 6922 static assert(is( immutable(shared(T)) == immutable(T) )); static assert(is( immutable( inout(T)) == immutable(T) )); static assert(is( immutable(T) == immutable(T) )); static assert(is( const(immutable(T)) == immutable(T) )); // 6922 static assert(is( shared(immutable(T)) == immutable(T) )); // 6338 static assert(is( inout(immutable(T)) == immutable(T) )); static assert(is( immutable(shared(const(T))) == immutable(T) )); static assert(is( immutable(const(shared(T))) == immutable(T) )); static assert(is( shared(immutable(const(T))) == immutable(T) )); static assert(is( shared(const(immutable(T))) == immutable(T) )); static assert(is( const(shared(immutable(T))) == immutable(T) )); static assert(is( const(immutable(shared(T))) == immutable(T) )); static assert(is( immutable(shared(inout(T))) == immutable(T) )); static assert(is( immutable(inout(shared(T))) == immutable(T) )); static assert(is( shared(immutable(inout(T))) == immutable(T) )); static assert(is( shared(inout(immutable(T))) == immutable(T) )); static assert(is( inout(shared(immutable(T))) == immutable(T) )); static assert(is( inout(immutable(shared(T))) == immutable(T) )); /************************************/ // 6912 void test6912() { // From To static assert( is( int [] : int [] )); static assert(!is( inout(int []) : int [] )); static assert(!is( int [] : inout(int []) )); static assert( is( inout(int []) : inout(int []) )); static assert( is( int [] : const(int)[] )); static assert( is( inout(int []) : const(int)[] )); static assert(!is( int [] : inout(const(int)[]) )); static assert( is( inout(int []) : inout(const(int)[]) )); static assert( is( const(int)[] : const(int)[] )); static assert( is( inout(const(int)[]) : const(int)[] )); static assert(!is( const(int)[] : inout(const(int)[]) )); static assert( is( inout(const(int)[]) : inout(const(int)[]) )); static assert( is( immutable(int)[] : const(int)[] )); static assert( is( inout(immutable(int)[]) : const(int)[] )); static assert( is( immutable(int)[] : inout(const(int)[]) )); static assert( is( inout(immutable(int)[]) : inout(const(int)[]) )); static assert( is( immutable(int)[] : immutable(int)[] )); static assert( is( inout(immutable(int)[]) : immutable(int)[] )); static assert( is( immutable(int)[] : inout(immutable(int)[]) )); static assert( is( inout(immutable(int)[]) : inout(immutable(int)[]) )); static assert( is( inout(int)[] : inout(int)[] )); static assert( is( inout(inout(int)[]) : inout(int)[] )); static assert( is( inout(int)[] : inout(inout(int)[]) )); static assert( is( inout(inout(int)[]) : inout(inout(int)[]) )); static assert( is( inout(int)[] : const(int)[] )); static assert( is( inout(inout(int)[]) : const(int)[] )); static assert( is( inout(int)[] : inout(const(int)[]) )); static assert( is( inout(inout(int)[]) : inout(const(int)[]) )); // From To static assert( is( int [int] : int [int] )); static assert(!is( inout(int [int]) : int [int] )); static assert(!is( int [int] : inout(int [int]) )); static assert( is( inout(int [int]) : inout(int [int]) )); static assert( is( int [int] : const(int)[int] )); static assert(!is( inout(int [int]) : const(int)[int] )); static assert(!is( int [int] : inout(const(int)[int]) )); static assert( is( inout(int [int]) : inout(const(int)[int]) )); static assert( is( const(int)[int] : const(int)[int] )); static assert(!is( inout(const(int)[int]) : const(int)[int] )); static assert(!is( const(int)[int] : inout(const(int)[int]) )); static assert( is( inout(const(int)[int]) : inout(const(int)[int]) )); static assert( is( immutable(int)[int] : const(int)[int] )); static assert(!is( inout(immutable(int)[int]) : const(int)[int] )); static assert(!is( immutable(int)[int] : inout(const(int)[int]) )); static assert( is( inout(immutable(int)[int]) : inout(const(int)[int]) )); static assert( is( immutable(int)[int] : immutable(int)[int] )); static assert(!is( inout(immutable(int)[int]) : immutable(int)[int] )); static assert(!is( immutable(int)[int] : inout(immutable(int)[int]) )); static assert( is( inout(immutable(int)[int]) : inout(immutable(int)[int]) )); static assert( is( inout(int)[int] : inout(int)[int] )); static assert(!is( inout(inout(int)[int]) : inout(int)[int] )); static assert(!is( inout(int)[int] : inout(inout(int)[int]) )); static assert( is( inout(inout(int)[int]) : inout(inout(int)[int]) )); static assert( is( inout(int)[int] : const(int)[int] )); static assert(!is( inout(inout(int)[int]) : const(int)[int] )); static assert(!is( inout(int)[int] : inout(const(int)[int]) )); static assert( is( inout(inout(int)[int]) : inout(const(int)[int]) )); // Regression check static assert( is( const(int)[] : const(int[]) ) ); // From To static assert( is( int * : int * )); static assert(!is( inout(int *) : int * )); static assert(!is( int * : inout(int *) )); static assert( is( inout(int *) : inout(int *) )); static assert( is( int * : const(int)* )); static assert( is( inout(int *) : const(int)* )); static assert(!is( int * : inout(const(int)*) )); static assert( is( inout(int *) : inout(const(int)*) )); static assert( is( const(int)* : const(int)* )); static assert( is( inout(const(int)*) : const(int)* )); static assert(!is( const(int)* : inout(const(int)*) )); static assert( is( inout(const(int)*) : inout(const(int)*) )); static assert( is( immutable(int)* : const(int)* )); static assert( is( inout(immutable(int)*) : const(int)* )); static assert( is( immutable(int)* : inout(const(int)*) )); static assert( is( inout(immutable(int)*) : inout(const(int)*) )); static assert( is( immutable(int)* : immutable(int)* )); static assert( is( inout(immutable(int)*) : immutable(int)* )); static assert( is( immutable(int)* : inout(immutable(int)*) )); static assert( is( inout(immutable(int)*) : inout(immutable(int)*) )); static assert( is( inout(int)* : inout(int)* )); static assert( is( inout(inout(int)*) : inout(int)* )); static assert( is( inout(int)* : inout(inout(int)*) )); static assert( is( inout(inout(int)*) : inout(inout(int)*) )); static assert( is( inout(int)* : const(int)* )); static assert( is( inout(inout(int)*) : const(int)* )); static assert( is( inout(int)* : inout(const(int)*) )); static assert( is( inout(inout(int)*) : inout(const(int)*) )); } /************************************/ // 6930 void test6930a() { inout(const int) f1(inout(const int) i) { return i; } int mi; const int ci; immutable int ii; static assert(is(typeof(f1(mi)) == const(int))); static assert(is(typeof(f1(ci)) == const(int))); static assert(is(typeof(f1(ii)) == immutable(int))); inout(const int)* f2(inout(const int)* p) { return p; } int * mp; const(int)* cp; immutable(int)* ip; static assert(is(typeof(f2(mp)) == const(int)*)); static assert(is(typeof(f2(cp)) == const(int)*)); static assert(is(typeof(f2(ip)) == immutable(int)*)); inout(const int)[] f3(inout(const int)[] a) { return a; } int [] ma; const(int)[] ca; immutable(int)[] ia; static assert(is(typeof(f3(ma)) == const(int)[])); static assert(is(typeof(f3(ca)) == const(int)[])); static assert(is(typeof(f3(ia)) == immutable(int)[])); inout(const int[1]) f4(inout(const int[1]) sa) { return sa; } int[1] msa; const int[1] csa; immutable int[1] isa; static assert(is(typeof(f4(msa)) == const(int)[1])); static assert(is(typeof(f4(csa)) == const(int)[1])); static assert(is(typeof(f4(isa)) == immutable(int)[1])); inout(const int)[string] f5(inout(const int)[string] aa) { return aa; } int [string] maa; const(int)[string] caa; immutable(int)[string] iaa; static assert(is(typeof(f5(maa)) == const(int)[string])); static assert(is(typeof(f5(caa)) == const(int)[string])); static assert(is(typeof(f5(iaa)) == immutable(int)[string])); } inout(const(int[])) foo6930(inout(int)[] x) { bool condition = cast(bool)(x.length / 2); return condition ? x : new immutable(int[])(2); } void test6930b(inout int = 0) { alias T1 = inout(shared(const(int))); static assert(T1.stringof == "shared(inout(const(int)))"); static assert(is(T1 == shared) && is(T1 == const) && is(T1 == inout)); alias T2 = const(shared(inout(int)[])); static assert(T2.stringof == "shared(const(inout(int)[]))"); static assert(is(T2 == shared) && is(T2 == const) && !is(T2 == inout) && is(typeof(T2.init[0]) == inout)); int [] ma; const(int)[] ca; immutable(int)[] ia; inout(int)[] wa; static assert(is(typeof(foo6930(ma)) == const int[])); static assert(is(typeof(foo6930(ca)) == const int[])); static assert(is(typeof(foo6930(ia)) == immutable int[])); static assert(is(typeof(foo6930(wa)) == inout const int[])); } /************************************/ // 11868 void f11868(A...)(A) { } void g11868(inout(const(int))[] arr) { f11868(arr[0]); } void test11868() { auto arr = [1,2,3]; g11868(arr); } /************************************/ // 11924 inout(StringType) localize11924(StringType)(inout StringType str, string locale) { return str; } struct S11924 { static menuItem_1(ARGS...)() { enum itemTitle = ARGS; } static content_left_1() { menuItem!(localize11924("Home", "")); } alias menuItem = menuItem_1; } /************************************/ // 11966 inout(char)[] stripped11966 (inout(char)[] path) { return path; } struct PathParser11966 { inout(const(char))[] path() inout { return null; } inout(const(char))[] pop() inout { return stripped11966(path); } } void test11966() { auto a = PathParser11966().pop(); } /************************************/ // 14788 auto make14788(K, V)(inout V[K] aa) { static struct Result { V[K] aa; ref front() inout { return aa[1]; } } return inout Result(aa); } void test14788() { int[int] aa = [1:1]; make14788(aa).front(); } /************************************/ // 12089 void foo12089(inout(char[]) a) { validate12089(a); } void validate12089(S)(in S str) { decodeImpl12089(str); } void decodeImpl12089(S)(auto ref S str) {} /************************************/ // 12524 inout(int) dup12524(inout(const(int)) val) { return val; } void test12524(inout(int)) { inout(const(int)) val; auto bug = dup12524(val); static assert(is(typeof(bug) == inout(int))); } /************************************/ // 6941 static assert((const(shared(int[])[])).stringof == "const(shared(int[])[])"); // fail static assert((const(shared(int[])[])).stringof != "const(shared(const(int[]))[])"); // fail static assert((inout(shared(int[])[])).stringof == "inout(shared(int[])[])"); // fail static assert((inout(shared(int[])[])).stringof != "inout(shared(inout(int[]))[])"); // fail /************************************/ // 6872 static assert((shared(inout(int)[])).stringof == "shared(inout(int)[])"); static assert((shared(inout(const(int)[]))).stringof == "shared(inout(const(int)[]))"); static assert((shared(inout(const(int)[])[])).stringof == "shared(inout(const(int)[])[])"); static assert((shared(inout(const(immutable(int)[])[])[])).stringof == "shared(inout(const(immutable(int)[])[])[])"); /************************************/ // 6939 void test6939() { shared int* x; immutable int* y; const int* z; static assert( is(typeof(1?x:y) == shared(const(int))*)); // fail static assert(!is(typeof(1?x:y) == const(int)*)); // fail static assert(!is(typeof(1?x:z))); // fail shared int[] a; immutable int[] b; const int[] c; static assert( is(typeof(1?a:b) == shared(const(int))[])); // pass (ok) static assert(!is(typeof(1?a:b) == const(int)[])); // pass (ok) static assert(!is(typeof(1?a:c))); // fail } /************************************/ // 6940 void test6940() { immutable(int*)* x; int** y; static assert(is(typeof(x) : const(int*)*)); // ok static assert(is(typeof(y) : const(int*)*)); // ok static assert(is(typeof(1?x:y) == const(int*)*)); immutable(int[])[] a; int[][] b; static assert(is(typeof(a) : const(int[])[])); // ok static assert(is(typeof(b) : const(int[])[])); // ok static assert(is(typeof(1?a:b) == const(int[])[])); immutable(int)** v; int** w; static assert(is(typeof(1?v:w) == const(int*)*)); } /************************************/ // 6982 void test6982() { alias int Bla; immutable(Bla[string]) ifiles = ["a":1, "b":2, "c":3]; static assert(!__traits(compiles, { immutable(Bla)[string] files = ifiles; })); // (1) static assert(!__traits(compiles, { ifiles.remove ("a"); })); // (2) immutable(int)[int] maa; const(immutable(int)[int]) caa; immutable( int [int]) iaa; static assert(!__traits(compiles, { maa = iaa; })); static assert(!__traits(compiles, { maa = caa; })); } /************************************/ // 7038 static assert(is(S7038 == const)); const struct S7038{ int x; } static assert(is(S7038 == const)); shared struct S7038b{ int x; } static assert(is(S7038b == shared)); immutable struct S7038c{ int x; } static assert(is(S7038c == immutable)); static assert(!is(C7038 == const)); const class C7038{ int x; } static assert(!is(C7038 == const)); void test7038() { S7038 s; static assert(is(typeof(s) == const)); static assert(is(typeof(s.x) == const int)); C7038 c; static assert(!is(typeof(c) == const)); static assert(is(typeof(c.x) == const int)); } /************************************/ // 7105 void copy(inout(int)** tgt, inout(int)* src){ *tgt = src; } void test7105() { int* pm; int m; copy(&pm, &m); assert(pm == &m); const(int)* pc; const(int) c; copy(&pc, &c); assert(pc == &c); immutable(int)* pi; immutable(int) i; copy(&pi, &i); assert(pi == &i); static assert(!__traits(compiles, copy(&pm, &c))); static assert(!__traits(compiles, copy(&pm, &i))); copy(&pc, &m); assert(pc == &m); copy(&pc, &i); assert(pc == &i); static assert(!__traits(compiles, copy(&pi, &m))); static assert(!__traits(compiles, copy(&pi, &c))); } /************************************/ // 7202 void test7202() { void writeln(string s) @system { printf("%.*s\n", s.length, s.ptr); } void delegate() @system x = { writeln("I am @system"); }; void delegate() @safe y = { }; auto px = &x; auto py = &y; static assert(!__traits(compiles, px = py)); // accepts-invalid *px = x; y(); // "I am @system" -> no output, OK } /************************************/ // 7554 T outer7554(T)(immutable T function(T) pure foo) pure { pure int inner() { return foo(5); } return inner(); } int sqr7554(int x) pure { return x * x; } void test7554() { assert(outer7554(&sqr7554) == 25); immutable(int function(int) pure) ifp = &sqr7554; } /************************************/ bool empty(T)(in T[] a) { assert(is(T == shared(string))); return false; } void test7518() { shared string[] stuff; stuff.empty(); } /************************************/ // 7669 shared(inout U)[n] id7669(U, size_t n)( shared(inout U)[n] ); void test7669() { static assert(is(typeof( id7669((shared(int)[3]).init)) == shared(int)[3])); } /************************************/ // 7757 inout(int) foo7757a(int x, lazy inout(int) def) { return def; } inout(int)[] foo7757b(int x, lazy inout(int)[] def) { return def; } inout(int)[int] foo7757c(int x, lazy inout(int)[int] def) { return def; } inout(T) bar7757a(T)(T x, lazy inout(T) def) { return def; } inout(T)[] bar7757b(T)(T x, lazy inout(T)[] def) { return def; } inout(T)[T] bar7757c(T)(T x, lazy inout(T)[T] def) { return def; } inout(Object) get7757(lazy inout(Object) defVal) { return null; } void test7757() { int mx1 = foo7757a(1,2); const(int) cx1 = foo7757a(1,2); int [] ma1 = foo7757b(1,[2]); const(int)[] ca1 = foo7757b(1,[2]); int [int] maa1 = foo7757c(1,[2:3]); const(int)[int] caa1 = foo7757c(1,[2:3]); int mx2 = bar7757a(1,2); const(int) cx2 = bar7757a(1,2); int [] ma2 = bar7757b(1,[2]); const(int)[] ca2 = bar7757b(1,[2]); int [int] maa2 = bar7757c(1,[2:3]); const(int)[int] caa2 = bar7757c(1,[2:3]); Object defObj = null; auto resObj = get7757(defObj); } /************************************/ // 8098 class Outer8098 { int i = 6; class Inner { int y=0; void foo() const { static assert(is(typeof(this.outer) == const(Outer8098))); static assert(is(typeof(i) == const(int))); static assert(!__traits(compiles, ++i)); } } Inner inner; this() { inner = new Inner; } } void test8098() { const(Outer8098) x = new Outer8098(); static assert(is(typeof(x) == const(Outer8098))); static assert(is(typeof(x.inner) == const(Outer8098.Inner))); } /************************************/ // 8099 void test8099() { static class Outer { class Inner {} } auto m = new Outer; auto c = new const(Outer); auto i = new immutable(Outer); auto mm = m.new Inner; // m -> m OK auto mc = m.new const(Inner); // m -> c OK static assert(!__traits(compiles, { auto mi = m.new immutable(Inner); // m -> i bad })); static assert(!__traits(compiles, { auto cm = c.new Inner; // c -> m bad })); auto cc = c.new const(Inner); // c -> c OK static assert(!__traits(compiles, { auto ci = c.new immutable(Inner); // c -> i bad })); static assert(!__traits(compiles, { auto im = i.new Inner; // i -> m bad })); auto ic = i.new const(Inner); // i -> c OK auto ii = i.new immutable(Inner); // i -> i OK } /************************************/ // 8201 void test8201() { uint[2] msa; immutable uint[2] isa = msa; ubyte[] buffer = [0, 1, 2, 3, 4, 5]; immutable ubyte[4] iArr = buffer[0 .. 4]; } /************************************/ // 8212 struct S8212 { int x; } shared S8212 s8212; shared int x8212; void test8212() { int y = x8212; S8212 s2 = s8212; } /************************************/ // 8366 class B8366 { bool foo(in Object o) const { return true; } } class C8366a : B8366 { bool foo(in Object o) { return true; } override bool foo(in Object o) const { return false; } bool foo(in Object o) immutable { return true; } bool foo(in Object o) shared { return true; } bool foo(in Object o) shared const { return true; } } class C8366b : B8366 { bool foo(in Object o) { return false; } alias super.foo foo; bool foo(in Object o) immutable { return false; } bool foo(in Object o) shared { return false; } bool foo(in Object o) shared const { return false; } } void test8366() { { C8366a mca = new C8366a(); const C8366a cca = new C8366a(); B8366 mb = mca; const B8366 cb = cca; assert(mca.foo(null) == true); assert(cca.foo(null) == false); assert(mb .foo(null) == false); assert(cb .foo(null) == false); } { C8366b mcb = new C8366b(); const C8366b ccb = new C8366b(); B8366 mb = mcb; const B8366 cb = ccb; assert(mcb.foo(null) == false); assert(ccb.foo(null) == true); assert(mb .foo(null) == true); assert(cb .foo(null) == true); } } /************************************/ // 8408 template hasMutableIndirection8408(T) { template Unqual(T) { static if (is(T U == shared(const U))) alias U Unqual; else static if (is(T U == const U )) alias U Unqual; else static if (is(T U == immutable U )) alias U Unqual; else static if (is(T U == inout U )) alias U Unqual; else static if (is(T U == shared U )) alias U Unqual; else alias T Unqual; } enum hasMutableIndirection8408 = !is(typeof({ Unqual!T t = void; immutable T u = t; })); } static assert(!hasMutableIndirection8408!(int)); static assert(!hasMutableIndirection8408!(int[3])); static assert( hasMutableIndirection8408!(Object)); auto dup8408(E)(inout(E)[] arr) pure @trusted { static if (hasMutableIndirection8408!E) { auto copy = new E[](arr.length); copy[] = cast(E[])arr[]; // assume constant return cast(inout(E)[])copy; // assume constant } else { auto copy = new E[](arr.length); copy[] = arr[]; return copy; } } void test8408() { void test(E, bool constConv)() { E[] marr = [E.init, E.init, E.init]; immutable E[] iarr = [E.init, E.init, E.init]; E[] m2m = marr.dup8408(); assert(m2m == marr); immutable E[] i2i = iarr.dup8408(); assert(i2i == iarr); static if (constConv) { // If dup() hss strong purity, implicit conversion is allowed immutable E[] m2i = marr.dup8408(); assert(m2i == marr); E[] i2m = iarr.dup8408(); assert(i2m == iarr); } else { static assert(!is(typeof({ immutable E[] m2i = marr.dup8408(); }))); static assert(!is(typeof({ E[] i2m = iarr.dup8408(); }))); } } class C {} struct S1 { long n; } struct S2 { int* p; } struct T1 { S1 s; } struct T2 { S2 s; } struct T3 { S1 s1; S2 s2; } test!(int , true )(); test!(int[3], true )(); test!(C , false)(); test!(S1 , true )(); test!(S2 , false)(); test!(T1 , true )(); test!(T2 , false)(); test!(T3 , false)(); } /************************************/ // 8688 void test8688() { alias TypeTuple!(int) T; foreach (i; TypeTuple!(0)) { alias const(T[i]) X; static assert(!is(X == int)); // fails static assert( is(X == const(int))); // fails } } /************************************/ // 10946 (regression by fixing bug 8688, from 2.061) enum xlen10946 = 4; alias immutable(char)[xlen10946] e3; alias immutable(char[xlen10946]) e4; // NG -> OK immutable vlen10946 = 4; alias immutable(char)[vlen10946] i3; alias immutable(char[vlen10946]) i4; // NG -> OK /************************************/ // 9046 void test9046() { foreach (T; TypeTuple!(byte, ubyte, short, ushort, int, uint, long, ulong, char, wchar, dchar, float, double, real, ifloat, idouble, ireal, cfloat, cdouble, creal)) foreach (U; TypeTuple!(T, const T, immutable T, shared T, shared const T, inout T, shared inout T)) { static assert(is(typeof(U.init) == U)); } foreach (T; TypeTuple!(int[], const(char)[], immutable(string[]), shared(const(int)[])[], int[1], const(char)[1], immutable(string[1]), shared(const(int)[1])[], int[int], const(char)[long], immutable(string[string]), shared(const(int)[double])[])) foreach (U; TypeTuple!(T, const T, immutable T, shared T, shared const T, inout T, shared inout T)) { static assert(is(typeof(U.init) == U)); } int i; enum E { x, y } static struct S {} static class C {} struct NS { void f(){ i++; } } class NC { void f(){ i++; } } foreach (T; TypeTuple!(E, S, C, NS, NC)) foreach (U; TypeTuple!(T, const T, immutable T, shared T, shared const T, inout T, shared inout T)) { static assert(is(typeof(U.init) == U)); } alias TL = TypeTuple!(int, string, int[int]); foreach (U; TypeTuple!(TL, const TL, immutable TL, shared TL, shared const TL, inout TL, shared inout TL)) { static assert(is(typeof(U.init) == U)); } } /************************************/ // 9090 void test9090() { void test1(T)(auto ref const T[] val) {} string a; test1(a); } /************************************/ // 9461 void test9461() { class A {} class B : A {} void conv(S, T)(ref S x) { T y = x; } // should be NG static assert(!__traits(compiles, conv!(inout(B)[], inout(A)[]))); static assert(!__traits(compiles, conv!(int[inout(B)], int[inout(A)]))); static assert(!__traits(compiles, conv!(inout(B)[int], inout(A)[int]))); static assert(!__traits(compiles, conv!(inout(B)*, inout(A)*))); static assert(!__traits(compiles, conv!(inout(B)[1], inout(A)[]))); // should be OK static assert( __traits(compiles, conv!(inout(B), inout(A)))); } /************************************/ struct S9209 { int x; } void bar9209(const S9209*) {} void test9209() { const f = new S9209(1); bar9209(f); } /************************************/ // 10758 struct X10758 { static: inout(int) screwUpVal(ref inout(int) wx) { return wx; } ref inout(int) screwUpRef(ref inout(int) wx) { return wx; } inout(int)* screwUpPtr(ref inout(int) wx) { return &wx; } inout(int)[] screwUpArr(ref inout(int) wx) { return (&wx)[0 .. 1]; } } struct S10758 { int x; inout(int) screwUpVal(ref inout(int) _) inout { return x; } ref inout(int) screwUpRef(ref inout(int) _) inout { return x; } inout(int)* screwUpPtr(ref inout(int) _) inout { return &x; } inout(int)[] screwUpArr(ref inout(int) _) inout { return (&x)[0 .. 1]; } } void test10758(ref inout(int) wx, inout(int)* wp, inout(int)[] wa, inout(S10758) ws) { inout(int) screwUpVal(inout(int) _) { return wx; } ref inout(int) screwUpRef(inout(int) _) { return wx; } inout(int)* screwUpPtr(inout(int) _) { return &wx; } inout(int)[] screwUpArr(inout(int) _) { return (&wx)[0 .. 1]; } struct NS { inout(int) screwUpVal() inout { return wx; } ref inout(int) screwUpRef() inout { return wx; } inout(int)* screwUpPtr() inout { return &wx; } inout(int)[] screwUpArr() inout { return (&wx)[0 .. 1]; } } int mx = 1; const(int) cx = 1; immutable(int) ix = 1; // nested inout function may return an inout reference of the context, // so substitude inout to mutable or immutable should be disallowed. { // value return does not leak any inout reference, so safe. screwUpVal(mx); screwUpVal(ix); screwUpVal(wx); screwUpVal(cx); static assert(!__traits(compiles, screwUpRef(mx))); static assert(!__traits(compiles, screwUpRef(ix))); screwUpRef(wx); screwUpRef(cx); static assert(!__traits(compiles, screwUpPtr(mx))); static assert(!__traits(compiles, screwUpPtr(ix))); screwUpPtr(wx); screwUpPtr(cx); static assert(!__traits(compiles, screwUpArr(mx))); static assert(!__traits(compiles, screwUpArr(ix))); screwUpArr(cx); screwUpArr(wx); } // inout method of the nested struct may return an inout reference of the context, { ( NS()).screwUpVal(); (immutable NS()).screwUpVal(); ( inout NS()).screwUpVal(); ( const NS()).screwUpVal(); static assert(!__traits(compiles, ( NS()).screwUpRef())); static assert(!__traits(compiles, (immutable NS()).screwUpRef())); (inout NS()).screwUpRef(); (const NS()).screwUpRef(); static assert(!__traits(compiles, ( NS()).screwUpPtr())); static assert(!__traits(compiles, (immutable NS()).screwUpPtr())); (inout NS()).screwUpPtr(); (const NS()).screwUpPtr(); static assert(!__traits(compiles, ( NS()).screwUpArr())); static assert(!__traits(compiles, (immutable NS()).screwUpArr())); (inout NS()).screwUpArr(); (const NS()).screwUpArr(); } // function pointer holds no context, so there's no screw up. { auto fp_screwUpVal = &X10758.screwUpVal; fp_screwUpVal(mx); fp_screwUpVal(ix); fp_screwUpVal(wx); fp_screwUpVal(cx); auto fp_screwUpRef = &X10758.screwUpRef; fp_screwUpRef(mx); fp_screwUpRef(ix); fp_screwUpRef(wx); fp_screwUpRef(cx); auto fp_screwUpPtr = &X10758.screwUpVal; fp_screwUpPtr(mx); fp_screwUpPtr(ix); fp_screwUpPtr(wx); fp_screwUpPtr(cx); auto fp_screwUpArr = &X10758.screwUpVal; fp_screwUpArr(mx); fp_screwUpArr(ix); fp_screwUpArr(wx); fp_screwUpArr(cx); } // inout delegate behaves same as nested functions. { auto dg_screwUpVal = &ws.screwUpVal; dg_screwUpVal(mx); dg_screwUpVal(ix); dg_screwUpVal(wx); dg_screwUpVal(cx); auto dg_screwUpRef = &ws.screwUpRef; static assert(!__traits(compiles, dg_screwUpRef(mx))); static assert(!__traits(compiles, dg_screwUpRef(ix))); dg_screwUpRef(wx); dg_screwUpRef(cx); auto dg_screwUpPtr = &ws.screwUpPtr; static assert(!__traits(compiles, dg_screwUpPtr(mx))); static assert(!__traits(compiles, dg_screwUpPtr(ix))); dg_screwUpPtr(wx); dg_screwUpPtr(cx); auto dg_screwUpArr = &ws.screwUpArr; static assert(!__traits(compiles, dg_screwUpArr(mx))); static assert(!__traits(compiles, dg_screwUpArr(ix))); dg_screwUpArr(cx); dg_screwUpArr(wx); } } /************************************/ // 10761 inout(int)* function(inout(int)*) fptr10761(inout(int)*) { static inout(int)* screwUp(inout(int)* x) { return x; } auto fp = &screwUp; static assert(is(typeof(fp) == inout(int)* function(inout(int)*) pure nothrow @nogc @safe)); return fp; } inout(int)* delegate(inout(int)*) nest10761(inout(int)* x) { inout(int)* screwUp(inout(int)* _) { return x; } auto dg = &screwUp; static assert(is(typeof(dg) == inout(int)* delegate(inout(int)*) pure nothrow @nogc @safe)); return dg; } struct S10761 { int x; inout(int)* screwUp() inout { return &x; } } inout(int)* delegate() inout memfn10761(inout(int)* x) { auto s = new inout S10761(1); auto dg = &s.screwUp; static assert(is(typeof(dg) == inout(int)* delegate() inout)); return dg; } void test10761() { int mx = 1; const(int) cx = 1; immutable(int) ix = 1; // inout substitution has no effect on function pointer type { auto fp_m = fptr10761(&mx); auto fp_c = fptr10761(&cx); auto fp_i = fptr10761(&ix); alias FP = inout(int)* function(inout(int)*); static assert(is(typeof(fp_m) == FP)); static assert(is(typeof(fp_c) == FP)); static assert(is(typeof(fp_i) == FP)); } // inout substitution on delegate type should always // modify inout to const. { auto dg_m = nest10761(&mx); auto dg_c = nest10761(&cx); auto dg_i = nest10761(&ix); alias DG = const(int)* delegate(const(int)*); static assert(is(typeof(dg_m) == DG)); static assert(is(typeof(dg_c) == DG)); static assert(is(typeof(dg_i) == DG)); } // same as above { auto dg_m = memfn10761(&mx); auto dg_c = memfn10761(&cx); auto dg_i = memfn10761(&ix); alias DG = const(int)* delegate() const; static assert(is(typeof(dg_m) == DG)); static assert(is(typeof(dg_c) == DG)); static assert(is(typeof(dg_i) == DG)); } } /************************************/ // 11226 void test11226() { typeof(null) m; const typeof(null) c = m; immutable typeof(null) i = m; m = m, m = c, m = i; assert(m == c); assert(m == i); assert(c == i); static assert(is(typeof(true ? m : m) == typeof(null))); static assert(is(typeof(true ? m : c) == const typeof(null))); static assert(is(typeof(true ? m : i) == const typeof(null))); static assert(is(typeof(true ? c : m) == const typeof(null))); static assert(is(typeof(true ? c : c) == const typeof(null))); static assert(is(typeof(true ? c : i) == const typeof(null))); static assert(is(typeof(true ? i : m) == const typeof(null))); static assert(is(typeof(true ? i : c) == const typeof(null))); static assert(is(typeof(true ? i : i) == immutable typeof(null))); static assert(typeof(m).stringof == "typeof(null)" ); static assert(typeof(c).stringof == "const(typeof(null))"); static assert(typeof(i).stringof == "immutable(typeof(null))"); } /************************************/ // 11257 struct R11257 { union { const(Object) original; Object stripped; } } void test11257() { const(R11257) cr; R11257 mr = cr; // Error: cannot implicitly convert expression (cr) of type const(R) to R } /************************************/ // 11215 shared(inout(void)**) f11215(inout int); static assert(is(typeof(f11215(0)) == shared(void**))); static assert(is(typeof(f11215((const int).init)) == shared(const(void)**))); /************************************/ // 11489 void test11489(inout int = 0) { static class B {} static class D : B {} D [] dm; const(D)[] dc; inout(D)[] dw; shared(D)[] dsm; shared(const D)[] dsc; shared(inout D)[] dsw; immutable(D)[] di; static assert(!__traits(compiles, { B [] b = dm; })); static assert( __traits(compiles, { const(B)[] b = dm; })); static assert(!__traits(compiles, { inout(B)[] b = dm; })); static assert(!__traits(compiles, { shared(B)[] b = dm; })); static assert(!__traits(compiles, { shared(const B)[] b = dm; })); static assert(!__traits(compiles, { shared(inout B)[] b = dm; })); static assert(!__traits(compiles, { immutable(B)[] b = dm; })); static assert(!__traits(compiles, { B [] b = dc; })); static assert( __traits(compiles, { const(B)[] b = dc; })); static assert(!__traits(compiles, { inout(B)[] b = dc; })); static assert(!__traits(compiles, { shared(B)[] b = dc; })); static assert(!__traits(compiles, { shared(const B)[] b = dc; })); static assert(!__traits(compiles, { shared(inout B)[] b = dc; })); static assert(!__traits(compiles, { immutable(B)[] b = dc; })); static assert(!__traits(compiles, { B [] b = dw; })); static assert( __traits(compiles, { const(B)[] b = dw; })); static assert(!__traits(compiles, { inout(B)[] b = dw; })); static assert(!__traits(compiles, { shared(B)[] b = dw; })); static assert(!__traits(compiles, { shared(const B)[] b = dw; })); static assert(!__traits(compiles, { shared(inout B)[] b = dw; })); static assert(!__traits(compiles, { immutable(B)[] b = dw; })); static assert(!__traits(compiles, { B [] b = dsm; })); static assert(!__traits(compiles, { const(B)[] b = dsm; })); static assert(!__traits(compiles, { inout(B)[] b = dsm; })); static assert(!__traits(compiles, { shared(B)[] b = dsm; })); static assert( __traits(compiles, { shared(const B)[] b = dsm; })); static assert(!__traits(compiles, { shared(inout B)[] b = dsm; })); static assert(!__traits(compiles, { immutable(B)[] b = dsm; })); static assert(!__traits(compiles, { B [] b = dsc; })); static assert(!__traits(compiles, { const(B)[] b = dsc; })); static assert(!__traits(compiles, { inout(B)[] b = dsc; })); static assert(!__traits(compiles, { shared(B)[] b = dsc; })); static assert( __traits(compiles, { shared(const B)[] b = dsc; })); static assert(!__traits(compiles, { shared(inout B)[] b = dsc; })); static assert(!__traits(compiles, { immutable(B)[] b = dsc; })); static assert(!__traits(compiles, { B [] b = dsw; })); static assert(!__traits(compiles, { const(B)[] b = dsw; })); static assert(!__traits(compiles, { inout(B)[] b = dsw; })); static assert(!__traits(compiles, { shared(B)[] b = dsw; })); static assert( __traits(compiles, { shared(const B)[] b = dsw; })); static assert(!__traits(compiles, { shared(inout B)[] b = dsw; })); static assert(!__traits(compiles, { immutable(B)[] b = dsw; })); static assert(!__traits(compiles, { B [] b = di; })); static assert( __traits(compiles, { const(B)[] b = di; })); static assert(!__traits(compiles, { inout(B)[] b = di; })); static assert(!__traits(compiles, { shared(B)[] b = di; })); static assert( __traits(compiles, { shared(const B)[] b = di; })); static assert(!__traits(compiles, { shared(inout B)[] b = di; })); static assert( __traits(compiles, { immutable(B)[] b = di; })); } /************************************/ // 11768 void test11768(inout int = 0) { const(inout(char)) k1; inout(const(char)) k2; static assert(typeof(k1).stringof == "inout(const(char))"); // OK static assert(typeof(k2).stringof == "inout(const(char))"); // fails static assert(is(typeof(k1) == typeof(k2))); // fails } /************************************/ // 12403 void test12403() { void func(K, V)(inout(V[K]) aa) { static assert(is(V == const int)); static assert(is(K == int)); } const(int)[int] m; func(m); } /************************************/ // 13011 void test13011() { static size_t hashOf(int delegate() inout val) { return 0; } int delegate() inout dg; auto h = hashOf(dg); } /************************************/ // 13030 void va13030(Args...)(const Args args) {} void func13030(int delegate(int n) a) { va13030(a); } /************************************/ // 13802 & 13803 static assert(( string ).stringof == "string" ); static assert(( string[] ).stringof == "string[]" ); static assert(( string[1] ).stringof == "string[1]" ); static assert(( string[int]).stringof == "string[int]" ); static assert(( const string ).stringof == "const(string)" ); static assert(( const string[] ).stringof == "const(string[])" ); static assert(( const string[1] ).stringof == "const(string[1])" ); static assert(( const string[int]).stringof == "const(string[int])" ); static assert((shared string ).stringof == "shared(string)" ); static assert((shared string[] ).stringof == "shared(string[])" ); static assert((shared string[1] ).stringof == "shared(string[1])" ); static assert((shared string[int]).stringof == "shared(string[int])" ); static assert((shared const string ).stringof == "shared(const(string))" ); static assert((shared const string[] ).stringof == "shared(const(string[]))" ); static assert((shared const string[1] ).stringof == "shared(const(string[1]))" ); static assert((shared const string[int]).stringof == "shared(const(string[int]))"); static assert(( immutable string ).stringof == "immutable(string)" ); static assert(( immutable string[] ).stringof == "immutable(string[])" ); static assert(( immutable string[1] ).stringof == "immutable(string[1])" ); static assert(( immutable string[int]).stringof == "immutable(string[int])" ); static assert(( wstring ).stringof == "wstring" ); static assert(( wstring[] ).stringof == "wstring[]" ); static assert(( wstring[1] ).stringof == "wstring[1]" ); static assert(( wstring[int]).stringof == "wstring[int]" ); static assert(( const wstring ).stringof == "const(wstring)" ); static assert(( const wstring[] ).stringof == "const(wstring[])" ); static assert(( const wstring[1] ).stringof == "const(wstring[1])" ); static assert(( const wstring[int]).stringof == "const(wstring[int])" ); static assert((shared wstring ).stringof == "shared(wstring)" ); static assert((shared wstring[] ).stringof == "shared(wstring[])" ); static assert((shared wstring[1] ).stringof == "shared(wstring[1])" ); static assert((shared wstring[int]).stringof == "shared(wstring[int])" ); static assert((shared const wstring ).stringof == "shared(const(wstring))" ); static assert((shared const wstring[] ).stringof == "shared(const(wstring[]))" ); static assert((shared const wstring[1] ).stringof == "shared(const(wstring[1]))" ); static assert((shared const wstring[int]).stringof == "shared(const(wstring[int]))"); static assert(( immutable wstring ).stringof == "immutable(wstring)" ); static assert(( immutable wstring[] ).stringof == "immutable(wstring[])" ); static assert(( immutable wstring[1] ).stringof == "immutable(wstring[1])" ); static assert(( immutable wstring[int]).stringof == "immutable(wstring[int])" ); static assert(( dstring ).stringof == "dstring" ); static assert(( dstring[] ).stringof == "dstring[]" ); static assert(( dstring[1] ).stringof == "dstring[1]" ); static assert(( dstring[int]).stringof == "dstring[int]" ); static assert(( const dstring ).stringof == "const(dstring)" ); static assert(( const dstring[] ).stringof == "const(dstring[])" ); static assert(( const dstring[1] ).stringof == "const(dstring[1])" ); static assert(( const dstring[int]).stringof == "const(dstring[int])" ); static assert((shared dstring ).stringof == "shared(dstring)" ); static assert((shared dstring[] ).stringof == "shared(dstring[])" ); static assert((shared dstring[1] ).stringof == "shared(dstring[1])" ); static assert((shared dstring[int]).stringof == "shared(dstring[int])" ); static assert((shared const dstring ).stringof == "shared(const(dstring))" ); static assert((shared const dstring[] ).stringof == "shared(const(dstring[]))" ); static assert((shared const dstring[1] ).stringof == "shared(const(dstring[1]))" ); static assert((shared const dstring[int]).stringof == "shared(const(dstring[int]))"); static assert(( immutable dstring ).stringof == "immutable(dstring)" ); static assert(( immutable dstring[] ).stringof == "immutable(dstring[])" ); static assert(( immutable dstring[1] ).stringof == "immutable(dstring[1])" ); static assert(( immutable dstring[int]).stringof == "immutable(dstring[int])" ); /************************************/ int main() { test1(); test2(); test3(); test4(); test5(); test6(); test8(); test9(); test10(); test11(); test12(); test13(); test14(); test15(); test16(); test17(); test18(); test19(); test20(); test21(); test22(); test23(); test24(); test25(); test26(); test27(); test28(); test29(); test30(); test31(); test32(); test33(); test34(); test35(); test36(); test37(); test38(); test39(); test40(); test41(); test42(); test43(); test44(); test45(); test46(); test47(); test48(); test49(); test50(); test51(); test52(); test53(); test54(); test55(); test56(); test57(); test58(); test59(); test60(); test61(); test62(); test63(); test64(); test65(); test66(); test68(); test69(); test70(); test72(); test73(); test74(); test75(); test76(); test77(); test78(); test79(); test80(); test81(); test82(); test83(); test84(); test85(); test87(); test4968(); test3748(); test1961a(); test1961b(); test1961c(); test88(); test4251a(); test4251b(); test5473(); test5493(); test5493inout(); test6782(); test6864(); test6865(); test6866(); test6870(); test6912(); test6930a(); test6930b(); test11868(); test6939(); test6940(); test6982(); test7038(); test7105(); test7202(); test7554(); test7518(); test7669(); test7757(); test8098(); test8099(); test8201(); test8212(); test8366(); test8408(); test8688(); test9046(); test9090(); test9461(); test9209(); test11226(); test11768(); test13011(); printf("Success\n"); return 0; }