Skip to content

Instantly share code, notes, and snippets.

@rikkimax

rikkimax/extracted.d

Created September 15, 2025 01:21
Show Gist options
  • Save rikkimax/652f96a33934bd8ae0a68fb849821385 to your computer and use it in GitHub Desktop.
Save rikkimax/652f96a33934bd8ae0a68fb849821385 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
extracted.d
module testdfa.extracted;
import core.stdc.stdio;
void funcCall()
{
static struct S
{
int field;
void method()
{
}
}
bool lookup(S** val) => true;
static bool anything() => true;
S* thing;
if (lookup(&thing))
{
assert(thing !is null); // ok, can't know what state thing is in
thing.field = 2;
}
assert(anything());
thing.method;
}
alias uttsC2 = unsignedToTempString!(2, false, char);
alias uttsC10 = unsignedToTempString!(10, false, char);
alias uttsC36 = unsignedToTempString!(36, false, char);
T[] unsignedToTempString(uint radix = 10, bool upperCase = false, T)(ulong value, return scope T[] buf)
if (radix >= 2 && radix <= 36 && (is(T == char) || is(T == wchar) || is(T == dchar)))
{
enum baseChar = upperCase ? 'A' : 'a';
size_t i = buf.length;
static if (size_t.sizeof == 4) // 32 bit CPU
{
if (value <= uint.max)
{
// use faster 32 bit arithmetic
uint val = cast(uint) value;
do
{
uint x = void;
if (val < radix)
{
x = cast(uint) val;
val = 0;
}
else
{
x = cast(uint)(val % radix);
val /= radix;
}
buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + baseChar);
}
while (val);
return buf[i .. $];
}
}
do
{
uint x = void;
if (value < radix)
{
x = cast(uint) value;
value = 0;
}
else
{
x = cast(uint)(value % radix);
value /= radix;
}
buf[--i] = cast(char)((radix <= 10 || x < 10) ? x + '0' : x - 10 + baseChar);
}
while (value);
return buf[i .. $];
}
enum EoperT
{
OPcomma,
OPinfo,
OPconst,
OPandand,
OPrelconst,
OPstring,
OPoror,
}
enum TYnoreturn = 1;
struct elem
{
EoperT Eoper;
elem* E2;
int Ety;
}
void elem_debug(elem* e)
{
}
int tybasic(int) => 1;
bool boolres(elem*) => false;
@trusted int iffalse(elem* e)
{
while (1)
{
assert(e);
elem_debug(e);
switch (e.Eoper)
{
case EoperT.OPcomma:
case EoperT.OPinfo:
e = e.E2;
break;
case EoperT.OPconst:
return !boolres(e);
case EoperT.OPandand:
return tybasic(e.E2.Ety) == TYnoreturn;
default:
return false;
}
}
}
@trusted int iftrue(elem* e)
{
while (1)
{
assert(e);
elem_debug(e);
switch (e.Eoper)
{
case EoperT.OPcomma:
case EoperT.OPinfo:
e = e.E2;
break;
case EoperT.OPrelconst:
case EoperT.OPconst:
case EoperT.OPstring:
return boolres(e);
case EoperT.OPoror:
return tybasic(e.E2.Ety) == TYnoreturn;
default:
return false;
}
}
}
enum JSONOptions
{
none,
escapeNonAsciiChars
}
alias structTestBitOption1 = structTestBitOption!char;
alias structTestBitOption2 = structTestBitOption!wchar;
alias structTestBitOption3 = structTestBitOption!dchar;
void structTestBitOption(Char)(JSONOptions options)
{
auto step1 = options & JSONOptions.escapeNonAsciiChars;
auto step2 = step1 != 0;
auto against = is(Char == dchar);
assert(step2 == against, "JSONOptions.escapeNonAsciiChars needs dchar strings");
}
void appendCopyTest()
{
static void appendCopy(T, T2)(ref T[] dest, T2[] source)
{
dest.length = dest.length + 1;
}
string[] dest;
string[] source = ["hello", "World"];
appendCopy(dest, source);
string got = dest[0];
}
void test231()
{
static class X231
{
void a()
{
}
void b(int z, short c)
{
}
void c(int z, short d)
{
}
}
auto z = new X231();
TypeInfo a = typeid(typeof(&z.a));
TypeInfo b = typeid(typeof(&z.b));
TypeInfo c = typeid(typeof(&z.c));
assert(a !is b, "1");
assert(a != b, "2");
assert(b == c, "3");
}
struct FPoint
{
float x, y;
}
void constructBezier(FPoint p0, FPoint p1, FPoint p2, ref FPoint[3] quad)
{
quad[0] = p0;
quad[1] = FPoint(p1.x, p1.y);
quad[$ - 1] = p2;
}
void test6189()
{
auto p0 = FPoint(0, 0);
auto p1 = FPoint(1, 1);
auto p2 = FPoint(2, 2);
// avoid inline of call
FPoint[3] quad;
auto f = &constructBezier;
f(p0, p1, p2, quad);
assert(quad == [p0, p1, p2]);
}
void test8376()
{
int i = 0;
int[2] a;
a[1] = 1;
while (!a[0])
{
if (a[i])
continue;
a[i] = 1;
}
}
class A7375
{
}
class B7375(int i) : A7375
{
}
class C7375(int i) : B7375!i
{
}
void test7375()
{
A7375 foo = new C7375!11();
assert(cast(B7375!22) foo is null);
}
void test2006()
{
string[][] aas = [];
assert(aas.length == 0);
aas ~= cast(string[])[];
assert(aas.length == 1);
aas = aas ~ cast(string[])[];
assert(aas.length == 2);
}
void test76()
{
int x, y;
bool which;
(which ? x : y) += 5;
assert(y == 5);
}
struct Foo124
{
int z = 3;
void opAssign(Foo124 x)
{
z = 2;
}
}
struct Bar124
{
int z = 3;
this(this)
{
z = 17;
}
}
void test124()
{
Foo124[string] stuff;
stuff["foo"] = Foo124.init;
assert(stuff["foo"].z == 3);
stuff["foo"] = Foo124.init;
assert(stuff["foo"].z == 2);
Bar124[string] stuff2;
Bar124 q;
stuff2["dog"] = q;
assert(stuff2["dog"].z == 17);
}
template TT4536(T...)
{
alias T TT4536;
}
void test4536()
{
auto x = TT4536!(int, long, [1, 2]).init;
assert(x[0] is int.init);
assert(x[1] is long.init);
assert(x[2] is [1, 2].init);
}
void test12153()
{
int[1] i, j;
bool b = true;
(b ? i : j)[] = [4];
assert(i == [4]);
// regression test
int[1][1] k, l;
(b ? k : l)[0 .. 1][0 .. 1] = [4];
assert(k == [[4]]);
}
void test14682a()
{
// operands
int[] a1;
int[][] a2;
int[][][] a3;
int[][][][] a4;
// results
int[] r1w = [];
assert(r1w.length == 0);
int[][] r2w = [];
assert(r2w.length == 0);
int[][][] r3w = [];
assert(r3w.length == 0);
int[][][][] r4w = [];
assert(r4w.length == 0);
// ----
int[][] r2x = [[]];
assert(r2x.length == 1 && r2x[0].length == 0);
int[][][] r3x = [[]];
assert(r3x.length == 1 && r3x[0].length == 0);
int[][][][] r4x = [[]];
assert(r4x.length == 1 && r4x[0].length == 0);
// ----
int[][][] r3y = [[[]]];
assert(r3y.length == 1 && r3y[0].length == 1 && r3y[0][0].length == 0);
int[][][][] r4y = [[[]]];
assert(r4y.length == 1 && r4y[0].length == 1 && r4y[0][0].length == 0);
// ----
int[][][][] r4z = [[[[]]]];
assert(r4z.length == 1 && r4z[0].length == 1 && r4z[0][0].length == 1 && r4z[0][0][0].length
== 0);
// ArrayLiteralExp conforms to the type of LHS.
{
auto x = a1 ~ [];
static assert(is(typeof(x) == typeof(a1)));
assert(x == r1w);
} // no ambiguity
{
auto x = a2 ~ [];
static assert(is(typeof(x) == typeof(a2)));
assert(x == r2w);
} // fix <- ambiguity
{
auto x = a3 ~ [];
static assert(is(typeof(x) == typeof(a3)));
assert(x == r3w);
} // fix <- ambiguity
{
auto x = a4 ~ [];
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4w);
} // fix <- ambiguity
// ----
//{ auto x = a1 ~ [[]] ; } // (see test14682b)
{
auto x = a2 ~ [[]];
static assert(is(typeof(x) == typeof(a2)));
assert(x == r2x);
} // no ambiguity
{
auto x = a3 ~ [[]];
static assert(is(typeof(x) == typeof(a3)));
assert(x == r3x);
} // fix <- ambiguity
{
auto x = a4 ~ [[]];
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4x);
} // fix <- ambiguity
// ----
static assert(!__traits(compiles, { auto x = a1 ~ [[[]]]; }));
//{ auto x = a2 ~ [[[]]] ; } // (see test14682b)
{
auto x = a3 ~ [[[]]];
static assert(is(typeof(x) == typeof(a3)));
assert(x == r3y);
} // no ambiguity
{
auto x = a4 ~ [[[]]];
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4y);
} // fix <- ambiguity
// ----
static assert(!__traits(compiles, { auto x = a1 ~ [[[[]]]]; }));
static assert(!__traits(compiles, { auto x = a2 ~ [[[[]]]]; }));
//{ auto x = a3 ~ [[[[]]]]; } // (see test14682b)
{
auto x = a4 ~ [[[[]]]];
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4z);
} // no ambiguity
// ArrayLiteralExp conforms to the type of RHS.
{
auto x = [] ~ a1;
static assert(is(typeof(x) == typeof(a1)));
assert(x == r1w);
} // no ambiguity
{
auto x = [] ~ a2;
static assert(is(typeof(x) == typeof(a2)));
assert(x == r2w);
} // fix <- ambiguity
{
auto x = [] ~ a3;
static assert(is(typeof(x) == typeof(a3)));
assert(x == r3w);
} // fix <- ambiguity
{
auto x = [] ~ a4;
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4w);
} // fix <- ambiguity
// ----
//{ auto x = [[]] ~ a1; } // (see test14682b)
{
auto x = [[]] ~ a2;
static assert(is(typeof(x) == typeof(a2)));
assert(x == r2x);
} // no ambiguity
{
auto x = [[]] ~ a3;
static assert(is(typeof(x) == typeof(a3)));
assert(x == r3x);
} // fix <- ambiguity
{
auto x = [[]] ~ a4;
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4x);
} // fix <- ambiguity
// ----
static assert(!__traits(compiles, { auto x = [[[]]] ~ a1; }));
//{ auto x = [[[]]] ~ a2; } // (see test14682b)
{
auto x = [[[]]] ~ a3;
static assert(is(typeof(x) == typeof(a3)));
assert(x == r3y);
} // no ambiguity
{
auto x = [[[]]] ~ a4;
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4y);
} // fix <- ambiguity
// ----
static assert(!__traits(compiles, { auto x = [[[[]]]] ~ a1; }));
static assert(!__traits(compiles, { auto x = [[[[]]]] ~ a2; }));
//{ auto x = [[[[]]]] ~ a3; } // (see test14682b)
{
auto x = [[[[]]]] ~ a4;
static assert(is(typeof(x) == typeof(a4)));
assert(x == r4z);
} // no ambiguity
}
void test14682b() @system
{
// operands
int[] a1;
int[][] a2;
int[][][] a3;
int[][][][] a4;
// results
int[][] r2a = [[], []];
assert(r2a.length == 2 && r2a[0].length == 0 && r2a[1].length == 0);
//int[][][] r3a = [[], [[]] ]; // should work, but doesn't
//int[][][][] r4a = [[], [[[]]]]; // should work, but doesn't
int[][][] r3a;
{
r3a.length = 2;
r3a[0] = [];
r3a[1] = [[]];
}
assert(r3a.length == 2 && r3a[0].length == 0 && r3a[1].length == 1 && r3a[1][0].length == 0);
int[][][][] r4a;
{
r4a.length = 2;
r4a[0] = [];
r4a[1] = [[[]]];
}
assert(r4a.length == 2 && r4a[0].length == 0 && r4a[1].length == 1
&& r4a[1][0].length == 1 && r4a[1][0][0].length == 0);
// ----
int[][] r2b = [[], []];
assert(r2b.length == 2 && r2b[1].length == 0 && r2b[0].length == 0);
//int[][][] r3b = [ [[]] , []]; // should work, but doesn't
//int[][][][] r4b = [[[[]]], []]; // should work, but doesn't
int[][][] r3b;
{
r3b.length = 2;
r3b[0] = [[]];
r3b[1] = [];
}
assert(r3b.length == 2 && r3b[1].length == 0 && r3b[0].length == 1 && r3b[0][0].length == 0);
int[][][][] r4b;
{
r4b.length = 2;
r4b[0] = [[[]]];
r4b[1] = [];
}
assert(r4b.length == 2 && r4b[1].length == 0 && r4b[0].length == 1
&& r4b[0][0].length == 1 && r4b[0][0][0].length == 0);
// ArrayLiteralExp conforms to the typeof(LHS)->arrayOf().
{
auto x = a1 ~ [[]];
static assert(is(typeof(x) == typeof(a1)[]));
assert(x == r2a);
} // fix
{
auto x = a2 ~ [[[]]];
static assert(is(typeof(x) == typeof(a2)[]));
assert(x == r3a);
} // fix
{
auto x = a3 ~ [[[[]]]];
static assert(is(typeof(x) == typeof(a3)[]));
assert(x == r4a);
} // fix
// ArrayLiteralExp conforms to the typeof(RHS)->arrayOf().
{
auto x = [[]] ~ a1;
static assert(is(typeof(x) == typeof(a1)[]));
assert(x == r2b);
} // fix
{
auto x = [[[]]] ~ a2;
static assert(is(typeof(x) == typeof(a2)[]));
assert(x == r3b);
} // fix
{
auto x = [[[[]]]] ~ a3;
static assert(is(typeof(x) == typeof(a3)[]));
assert(x == r4b);
} // fix
}
void foo6(lazy int expr, ...) @system
{
import core.vararg;
char[] tmp_msg = va_arg!(char[])(_argptr);
if (cast(int)(tmp_msg.ptr) == "food_for_thought".length)
assert(0, "length is in the pointer!");
assert(tmp_msg == "food_for_thought");
}
void test101()
{
int[] d1 = [6, 1, 2];
byte[] d2 = [6, 1, 2];
assert(d1 == d2);
d2 ~= [6, 1, 2];
assert(d1 != d2);
}
void test13154()
{
int[3] ints = [2, 1, 0, 1][0 .. 3];
float[3] floats0 = [2f, 1f, 0f, 1f][0 .. 3];
float[3] floats1 = [2.0, 1.0, 0.0, 1.0][0 .. 3]; // fails!
float[3] floats2 = [2.0f, 1.0f, 0.0f, 1.0f][0 .. 3];
assert(ints == [2, 1, 0]);
assert(floats0 == [2, 1, 0]);
assert(floats1 == [2, 1, 0]); // fail!
assert(floats1 != [0, 0, 0]); // fail!
assert(floats2 == [2, 1, 0]);
}
class ParentD
{
char[]* ptr;
~this()
{
*ptr ~= 'A';
}
}
class ChildD : ParentD
{
~this()
{
*ptr ~= 'B';
}
}
void testDeleteD() @system
{
char[] res;
ChildD cd = new ChildD();
cd.ptr = &res;
if (!__ctfe)
{
destroy(cd);
assert(res == "BA", cast(string) res);
}
}
void testDeleteDScope() @system
{
char[] res;
{
scope cd = new ChildD();
cd.ptr = &res;
}
assert(res == "BA", cast(string) res);
}
bool test13661a()
{
string op;
struct S
{
char x = 'x';
this(this)
{
op ~= x - 0x20;
} // upper case
~this()
{
op ~= x;
} // lower case
}
{
S[3] sa = [S('a'), S('b'), S('c')];
S[2] sb = sa[1 .. 3];
assert(sa == [S('a'), S('b'), S('c')]);
assert(sb == [S('b'), S('c')]);
sb[0].x = 'x';
sb[1].x = 'y';
assert(sa != [S('a'), S('x'), S('y')]); // OK <- incorrectly fails
assert(sa == [S('a'), S('b'), S('c')]); // OK <- incorrectly fails
assert(sb == [S('x'), S('y')]);
}
return true;
}
bool test14023()
{
string op;
struct S
{
char x = 'x';
this(this)
{
op ~= x - 0x20;
} // upper case
~this()
{
op ~= x;
} // lower case
}
S[2] makeSA()
{
return [S('p'), S('q')];
}
struct T
{
S[2][1] sb;
this(ref S[2] sa)
{
assert(op == "");
this.sb[0] = sa; // TOKconstruct
assert(sa == [S('b'), S('c')]);
assert(sb[0] == [S('b'), S('c')]);
}
}
void test(ref S[2] sa)
{
S[2][] a;
//a.length = 1; // will cause runtine AccessViolation
a ~= (S[2]).init;
assert(op == "");
a[0] = sa; // index <-- resolveSlice(newva)
assert(op == "BxCx");
assert(a[0] == [S('b'), S('c')]);
}
op = null;
{
S[3] sa = [S('a'), S('b'), S('c')];
T t = T(sa[1 .. 3]);
t.sb[0][0].x = 'x';
t.sb[0][1].x = 'y';
assert(sa != [S('a'), S('x'), S('y')]); // OK <- incorrectly fails
assert(sa == [S('a'), S('b'), S('c')]); // OK <- incorrectly fails
assert(t.sb[0] == [S('x'), S('y')]);
}
op = null;
{
S[2] sa = [S('a'), S('b')];
S[2][] a = [[S('x'), S('y')]];
assert(op == "");
a[0] = sa;
assert(op == "AxBy");
a[0] = makeSA();
assert(op == "AxByab");
}
assert(op == "AxByabba");
op = null;
{
S[3] sa = [S('a'), S('b'), S('c')];
test(sa[1 .. 3]);
assert(op == "BxCx");
}
assert(op == "BxCxcba");
return true;
}
void b10562()
{
{
int[3] ok = 3;
assert(ok == [3, 3, 3]);
ok = 1;
assert(ok == [1, 1, 1]);
int[][] da2;
assert(da2 == []);
}
{
int[3][2] a;
assert(a == [[0, 0, 0], [0, 0, 0]]);
int[3][2] b = 4;
assert(b == [[4, 4, 4], [4, 4, 4]]);
// b = 9;
// assert(b == [ [ 9, 9, 9 ], [ 9, 9, 9 ] ]);
int[3][2] c = [1, 2, 3];
assert(c == [[1, 2, 3], [1, 2, 3]]);
c = [5, 6, 7];
assert(c == [[5, 6, 7], [5, 6, 7]]);
int[3][2] d = [[1, 2, 3], [4, 5, 6]];
assert(d == [[1, 2, 3], [4, 5, 6]]);
}
{
int[3][2][4] a;
assert(a == [
[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [
[0, 0, 0], [0, 0, 0]
], [[0, 0, 0], [0, 0, 0]]
]);
// a = 1;
// assert(a == [ [ [ 1, 1, 1 ], [ 1, 1, 1 ] ],
// [ [ 1, 1, 1 ], [ 1, 1, 1 ] ],
// [ [ 1, 1, 1 ], [ 1, 1, 1 ] ],
// [ [ 1, 1, 1 ], [ 1, 1, 1 ] ] ]);
int[3][2][4] b = [1, 2, 3];
assert(b == [
[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]], [
[1, 2, 3], [1, 2, 3]
], [[1, 2, 3], [1, 2, 3]]
]);
// b = [ 4, 5, 6];
// assert(b == [ [ [ 4, 5, 6 ], [ 4, 5, 6 ] ],
// [ [ 4, 5, 6 ], [ 4, 5, 6 ] ],
// [ [ 4, 5, 6 ], [ 4, 5, 6 ] ],
// [ [ 4, 5, 6 ], [ 4, 5, 6 ] ] ]);
int[3][2][4] c = [[1, 2, 3], [4, 5, 6]];
assert(c == [
[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]], [
[1, 2, 3], [4, 5, 6]
], [[1, 2, 3], [4, 5, 6]]
]);
c = [[4, 5, 6], [7, 8, 9]];
assert(c == [
[[4, 5, 6], [7, 8, 9]], [[4, 5, 6], [7, 8, 9]], [
[4, 5, 6], [7, 8, 9]
], [[4, 5, 6], [7, 8, 9]]
]);
}
{
int[3] val = [4, 5, 6];
int[3][2][4] a = val[];
assert(a == [
[[4, 5, 6], [4, 5, 6]], [[4, 5, 6], [4, 5, 6]], [
[4, 5, 6], [4, 5, 6]
], [[4, 5, 6], [4, 5, 6]]
]);
}
{
// https://issues.dlang.org/show_bug.cgi?id=10562
int[3] value = [1, 2, 3];
int[3][2] a = value; // <-- COMPILATION ERROR
assert(a == [[1, 2, 3], [1, 2, 3]]);
}
{
// https://issues.dlang.org/show_bug.cgi?id=20465
int[][3][2] arr;
assert(arr == [[null, null, null], [null, null, null]]);
// int[] slice = [ 1 ];
// arr = slice;
// assert(arr == [[ slice, slice, slice ], [ slice, slice, slice ]]);
}
}
__gshared int global3632 = 1;
void test3632() @system
{
int test(T)()
{
static struct W
{
T f;
this(T g)
{
if (__ctfe || global3632)
f = g;
}
}
auto nan = W(T.nan);
auto nan2 = W(T.nan);
auto init = W(T.init);
auto init2 = W(T.init);
auto zero = W(cast(T) 0);
auto zero2 = W(cast(T) 0);
auto nzero2 = W(-cast(T) 0);
// Struct equality
assert(!(nan == nan2));
assert(!(nan == init2));
assert(!(init == init2));
assert((zero == zero2));
assert((zero == nzero2));
// Float equality
assert(!(nan.f == nan2.f));
assert(!(nan.f == init2.f));
assert(!(init.f == init2.f));
assert((zero.f == zero2.f));
assert((zero.f == nzero2.f));
// Struct identity
assert((nan is nan2));
assert((nan is init2));
assert((init is init2));
assert((zero is zero2));
assert(!(zero is nzero2));
// Float identity
assert((nan.f is nan2.f));
assert((nan.f is init2.f));
assert((init.f is init2.f));
assert((zero.f is zero2.f));
assert(!(zero.f is nzero2.f));
// Struct !identity
assert(!(nan !is nan2));
assert((nan is init2));
assert(!(init !is init2));
assert(!(zero !is zero2));
assert((zero !is nzero2));
// float !identity
assert(!(nan.f !is nan2.f));
assert((nan.f is init2.f));
assert(!(init.f !is init2.f));
assert(!(zero.f !is zero2.f));
assert((zero.f !is nzero2.f));
// .init identity
assert(W.init is W.init);
return 1;
}
auto rtF = test!float();
enum ctF = test!float();
auto rtD = test!double();
enum ctD = test!double();
auto rtR = test!real();
enum ctR = test!real();
assert(float.nan !is -float.nan);
assert(double.nan !is -double.nan);
assert(real.nan !is -real.nan);
}
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);
}
struct Sfix22372
{
int a1, a2, a3;
}
void throws2ndCall(ref Sfix22372 x)
{
}
void fix22372()
{
Sfix22372[] arr = [Sfix22372(), Sfix22372()];
size_t i;
try
{
for (i = 0; i < 2; i++)
throws2ndCall(arr[i]);
}
catch (Exception o)
{
//printf("Exception: i = %lu\n", i);
assert(i == 1); // this fails
}
}
void test36()
{
int i;
assert(typeid(i++) == typeid(int));
assert(i == 1);
assert(typeid(i + 1) == typeid(int));
}
class Eh : Exception
{
this()
{
super("Eh thrown");
}
}
void test4()
{
int x;
try
{
scope (exit)
{
printf("test1\n");
assert(x == 3);
x = 4;
}
scope (exit)
{
printf("test2\n");
assert(x == 2);
x = 3;
}
x = 2;
throw new Eh;
scope (exit)
{
printf("test3\n");
assert(x == 1);
x = 2;
}
printf("test4\n");
assert(x == 0);
x = 1;
}
catch (Eh e)
{
}
assert(x == 4);
}
void test5()
{
int x;
try
{
scope (success)
{
printf("test1\n");
assert(x == 3);
x = 4;
}
scope (success)
{
printf("test2\n");
assert(x == 2);
x = 3;
}
x = 2;
throw new Eh;
scope (success)
{
printf("test3\n");
assert(x == 1);
x = 2;
}
printf("test4\n");
assert(x == 0);
x = 1;
}
catch (Eh e)
{
}
assert(x == 2);
}
void test6()
{
int x;
scope (failure)
{
assert(0);
}
try
{
scope (failure)
{
printf("test1\n");
assert(x == 3);
x = 4;
}
scope (failure)
{
printf("test2\n");
assert(x == 2);
x = 3;
}
x = 2;
throw new Eh;
scope (failure)
{
printf("test3\n");
assert(x == 1);
x = 2;
}
printf("test4\n");
assert(x == 0);
x = 1;
}
catch (Eh e)
{
}
assert(x == 4);
}
void test51()
{
bool b;
assert(b == false);
b &= 1;
assert(b == false);
b |= 1;
assert(b == true);
b ^= 1;
assert(b == false);
b = b | true;
assert(b == true);
b = b & false;
assert(b == false);
b = b ^ true;
assert(b == true);
b = !b;
assert(b == false);
}
int test16140fun()
{
static int count = 0;
if (count == 3)
{
count = 0;
return 0;
}
++count;
return count;
}
void test16140()
{
uint[] res;
while (auto value = test16140fun())
res ~= value;
assert(res == [1, 2, 3]);
res.length = 0;
while (uint value = test16140fun())
res ~= value;
assert(res == [1, 2, 3]);
res.length = 0;
while (const value = test16140fun())
res ~= value;
assert(res == [1, 2, 3]);
}
void testThrowSideEffect()
{
static void foo(bool, void*, int)
{
}
bool b;
int i;
try
{
foo(b = true, throw new Exception(""), i++);
assert(false);
}
catch (Exception)
{
}
assert(b == true);
assert(i == 0);
}
bool test9745b()
{
void* b6 = cast(void*) 0xFEFEFEFE;
void* b7 = cast(void*) 0xFEFEFEFF;
assert(b6 is b6);
assert(b7 != b6);
return true;
}
static assert(test9745b());
int foo42(const(char)* x, ...)
{
import core.vararg;
va_list ap;
va_start!(typeof(x))(ap, x);
assert(ap != va_list.init);
int i;
i = va_arg!(typeof(i))(ap);
assert(i == 3);
long l;
l = va_arg!(typeof(l))(ap);
assert(l == 23);
uint k;
k = va_arg!(typeof(k))(ap);
assert(k == 4);
va_end(ap);
return cast(int)(i + l + k);
}
auto bug5852(const(string) s)
{
string[] r;
r ~= s;
assert(r.length == 1);
return r[0].length;
}
static assert(bug5852("abc") == 3);
void bug5976()
{
int[] barr;
int* k;
foreach (ref b; barr)
{
scope (failure)
k = &b;
k = &b;
}
}
void delegateInVariable()
{
int inc(ref uint num)
{
num++;
return 8675309;
}
uint myNum = 0;
auto incMyNumDel = &inc;
auto returnVal = incMyNumDel(myNum);
assert(myNum == 1);
}
void varEscapedIntoClass()
{
import std.range;
import std.algorithm.iteration;
import std.algorithm.comparison : equal;
size_t popCount = 0;
static class RefFwdRange
{
@safe:
this(size_t* pcount)
{
}
}
auto testdata = new RefFwdRange(&popCount);
assert(popCount == 9);
}
void test46()
{
TypeInfo ti = typeid(int*);
assert(!(ti is null));
assert(ti.tsize == (int*).sizeof);
assert(ti.toString() == "int*");
}
class TypeNext
{
Type next;
}
class Type
{
}
void typeNextIterate(Type t)
{
Type ts;
{
Type ta = new Type;
Type* pt;
for (pt = &ts; *pt != t; pt = &(cast(TypeNext)*pt).next)
{
}
*pt = ta;
}
}
struct Foo22(T)
{
}
void test22()
{
int i;
if ((Foo22!(char)).init == (Foo22!(char)).init)
i = 1;
assert(i == 1);
}
void foo8(ref bool b) {
b = true;
}
void test8()
{
bool b;
bool* pb = &b;
assert(b == false);
*pb = true;
assert(b == true);
*pb = false;
assert(b == false);
foo8(b);
assert(b == true);
}
struct Zero
{
int x;
}
void testZero()
{
auto zeroInit = __traits(initSymbol, Zero);
static assert(is(typeof(zeroInit) == const(void[])));
assert(zeroInit.ptr is null);
assert(zeroInit.length == Zero.sizeof);
}
struct SymPair {
ulong count;
void* sym;
SymPair* next;
}
void trace_sympair_add(SymPair** psp, void* s, ulong count)
{
SymPair* sp;
for (; 1; psp = &sp.next)
{
sp = *psp;
if (!sp)
{
sp = new SymPair;
sp.sym = s;
sp.count = 0;
sp.next = null;
*psp = sp;
break;
}
else if (sp.sym == s)
{
break;
}
}
sp.count += count;
}
struct RCArrayContainerCall()
{
nothrow:
this(size_t* cnt) { ++*(_cnt = cnt); }
~this() { if (_cnt) --*_cnt; }
this(this) { if (_cnt) ++*_cnt; }
size_t* _cnt;
}
void arrayContainerCall()
{
import core.internal.container.array;
static import common = core.internal.container.common;
alias RC = RCArrayContainerCall!();
Array!RC ary;
size_t cnt;
assert(cnt == 0);
ary.insertBack(RC(&cnt));
assert(cnt == 1);
ary.insertBack(RC(&cnt));
assert(cnt == 2);
ary.back = ary.front;
assert(cnt == 2);
ary.popBack();
assert(cnt == 1);
ary.popBack();
assert(cnt == 0);
}
Raw
layout
$ tree testdfa
testdfa
├── deimos
│   └── openssl
│   ├── _d_util.di
│   ├── aes.di
│   ├── applink.di
│   ├── asn1.di
│   ├── asn1_mac.di
│   ├── asn1t.di
│   ├── bio.di
│   ├── blowfish.di
│   ├── bn.di
│   ├── buffer.di
│   ├── camellia.di
│   ├── cast_.di
│   ├── cmac.di
│   ├── cms.di
│   ├── comp.di
│   ├── conf.di
│   ├── conf_api.di
│   ├── crypto.di
│   ├── des.di
│   ├── dh.di
│   ├── dsa.di
│   ├── dso.di
│   ├── dtls1.di
│   ├── e_os2.di
│   ├── ebcdic.di
│   ├── ec.di
│   ├── ecdh.di
│   ├── ecdsa.di
│   ├── engine.di
│   ├── err.di
│   ├── evp.di
│   ├── hmac.di
│   ├── idea.di
│   ├── kdf.di
│   ├── krb5_asn.di
│   ├── kssl.di
│   ├── lhash.di
│   ├── md4.di
│   ├── md5.di
│   ├── mdc2.di
│   ├── modes.di
│   ├── obj_mac.di
│   ├── objects.di
│   ├── ocsp.di
│   ├── opensslconf.di
│   ├── opensslv.di
│   ├── ossl_typ.di
│   ├── pem.di
│   ├── pem2.di
│   ├── pkcs12.di
│   ├── pkcs7.di
│   ├── pqueue.di
│   ├── prov_ssl.di
│   ├── rand.di
│   ├── rc2.di
│   ├── rc4.di
│   ├── ripemd.di
│   ├── rsa.di
│   ├── safestack.di
│   ├── seed.di
│   ├── sha.di
│   ├── srp.di
│   ├── srtp.di
│   ├── ssl.di
│   ├── ssl2.di
│   ├── ssl23.di
│   ├── ssl3.di
│   ├── stack.di
│   ├── symhacks.di
│   ├── tls1.di
│   ├── ts.di
│   ├── txt_db.di
│   ├── types.di
│   ├── ui.di
│   ├── ui_compat.di
│   ├── whrlpool.di
│   ├── x509.di
│   ├── x509_vfy.di
│   └── x509v3.di
├── demangle.d
├── errno.c
├── event.d
├── extracted.d
├── file.d
├── json.d
├── ocean
│   ├── application
│   │   └── components
│   │   ├── ConfigOverrides.d
│   │   ├── GCStats.d
│   │   ├── OpenFiles.d
│   │   ├── PidLock.d
│   │   ├── Signals.d
│   │   ├── TaskScheduler.d
│   │   ├── Timers.d
│   │   ├── UnixSocketCommands.d
│   │   └── Version.d
│   ├── core
│   │   ├── array
│   │   │   ├── DefaultPredicates.d
│   │   │   ├── Mutation.d
│   │   │   ├── Search.d
│   │   │   └── Transformation.d
│   │   ├── Array.d
│   │   ├── BitArray.d
│   │   ├── BitManip.d
│   │   ├── buffer
│   │   │   ├── NoIndirections.d
│   │   │   ├── Void.d
│   │   │   └── WithIndirections.d
│   │   ├── Buffer.d
│   │   ├── Buffer_test.d
│   │   ├── ByteSwap.d
│   │   ├── ContextUnion.d
│   │   ├── DeepCompare.d
│   │   ├── Enforce.d
│   │   ├── Enum.d
│   │   ├── Exception.d
│   │   ├── ExceptionDefinitions.d
│   │   ├── MessageFiber.d
│   │   ├── Optional.d
│   │   ├── SmartEnum.d
│   │   ├── SmartUnion.d
│   │   ├── StructConverter.d
│   │   ├── Test.d
│   │   ├── Tuple.d
│   │   ├── TypeConvert.d
│   │   ├── UnitTestRunner.d
│   │   ├── Verify.d
│   │   └── VersionCheck.d
│   ├── io
│   │   ├── compress
│   │   │   ├── CompressException.d
│   │   │   ├── lzo
│   │   │   │   ├── c
│   │   │   │   │   ├── lzo1x.d
│   │   │   │   │   └── lzoconf.d
│   │   │   │   ├── LzoChunk.d
│   │   │   │   ├── LzoChunkCompressor.d
│   │   │   │   ├── LzoCrc.d
│   │   │   │   └── LzoHeader.d
│   │   │   ├── Lzo.d
│   │   │   ├── ZipStream.d
│   │   │   └── ZlibStream.d
│   │   ├── console
│   │   │   ├── AppStatus.d
│   │   │   ├── readline
│   │   │   │   ├── c
│   │   │   │   │   ├── history.d
│   │   │   │   │   └── readline.d
│   │   │   │   ├── History.d
│   │   │   │   └── Readline.d
│   │   │   ├── StructTable.d
│   │   │   └── Tables.d
│   │   ├── Console.d
│   │   ├── device
│   │   │   ├── Array.d
│   │   │   ├── BitBucket.d
│   │   │   ├── Conduit.d
│   │   │   ├── Device.d
│   │   │   ├── DirectIO.d
│   │   │   ├── File.d
│   │   │   ├── FileMap.d
│   │   │   ├── IODevice.d
│   │   │   ├── MemoryDevice.d
│   │   │   └── TempFile.d
│   │   ├── digest
│   │   │   ├── FirstName.d
│   │   │   └── Fnv1.d
│   │   ├── FileException.d
│   │   ├── FilePath.d
│   │   ├── FileSystem.d
│   │   ├── model
│   │   │   ├── IConduit.d
│   │   │   ├── IFile.d
│   │   │   ├── ISuspendable.d
│   │   │   ├── ISuspendableThrottler.d
│   │   │   └── SuspendableThrottlerCount.d
│   │   ├── Path.d
│   │   ├── Retry.d
│   │   ├── select
│   │   │   ├── client
│   │   │   │   ├── EpollProcess.d
│   │   │   │   ├── FiberSelectEvent.d
│   │   │   │   ├── FiberTimerEvent.d
│   │   │   │   ├── FileSystemEvent.d
│   │   │   │   ├── model
│   │   │   │   │   ├── IFiberSelectClient.d
│   │   │   │   │   ├── ISelectClient.d
│   │   │   │   │   └── ISelectClientInfo.d
│   │   │   │   ├── SelectEvent.d
│   │   │   │   ├── SignalEvent.d
│   │   │   │   ├── TimerEvent.d
│   │   │   │   └── TimerSet.d
│   │   │   ├── EpollSelectDispatcher.d
│   │   │   ├── fiber
│   │   │   │   └── SelectFiber.d
│   │   │   ├── protocol
│   │   │   │   ├── fiber
│   │   │   │   │   ├── BufferedFiberSelectWriter.d
│   │   │   │   │   ├── FiberSelectReader.d
│   │   │   │   │   ├── FiberSelectWriter.d
│   │   │   │   │   ├── FiberSocketConnection.d
│   │   │   │   │   └── model
│   │   │   │   │   └── IFiberSelectProtocol.d
│   │   │   │   ├── generic
│   │   │   │   │   └── ErrnoIOException.d
│   │   │   │   ├── SelectReader.d
│   │   │   │   └── task
│   │   │   │   ├── internal
│   │   │   │   │   └── BufferedReader.d
│   │   │   │   ├── TaskSelectClient.d
│   │   │   │   ├── TaskSelectTransceiver.d
│   │   │   │   ├── TaskSelectTransceiver_test.d
│   │   │   │   └── TimeoutException.d
│   │   │   ├── selector
│   │   │   │   ├── EpollException.d
│   │   │   │   ├── EpollFdSanity.d
│   │   │   │   ├── IEpollSelectDispatcherInfo.d
│   │   │   │   ├── model
│   │   │   │   │   └── ISelectedKeysHandler.d
│   │   │   │   ├── RegisteredClients.d
│   │   │   │   ├── SelectedKeysHandler.d
│   │   │   │   └── TimeoutSelectedKeysHandler.d
│   │   │   └── timeout
│   │   │   └── TimerEventTimeoutManager.d
│   │   ├── serialize
│   │   │   ├── PHPSerializer.d
│   │   │   ├── SimpleStreamSerializer.d
│   │   │   ├── StringStructSerializer.d
│   │   │   ├── StructSerializer.d
│   │   │   └── TypeId.d
│   │   ├── Stdout.d
│   │   ├── stream
│   │   │   ├── Buffered.d
│   │   │   ├── Data.d
│   │   │   ├── DataFile.d
│   │   │   ├── Delimiters.d
│   │   │   ├── Format.d
│   │   │   ├── Iterator.d
│   │   │   ├── Lines.d
│   │   │   ├── Quotes.d
│   │   │   ├── Text.d
│   │   │   ├── TextFile.d
│   │   │   └── Zlib_internal.d
│   │   ├── Terminal.d
│   │   └── vfs
│   │   ├── FileFolder.d
│   │   ├── LinkedFolder.d
│   │   ├── model
│   │   │   └── Vfs.d
│   │   └── VirtualFolder.d
│   ├── LibFeatures.d
│   ├── math
│   │   ├── Bessel.d
│   │   ├── BinaryHistogram.d
│   │   ├── Bracket.d
│   │   ├── Convert.d
│   │   ├── Distribution.d
│   │   ├── Elliptic.d
│   │   ├── ErrorFunction.d
│   │   ├── GammaFunction.d
│   │   ├── IEEE.d
│   │   ├── IncrementalAverage.d
│   │   ├── IrregularMovingAverage.d
│   │   ├── Math.d
│   │   ├── Probability.d
│   │   ├── random
│   │   │   ├── engines
│   │   │   │   ├── ArraySource.d
│   │   │   │   ├── CMWC.d
│   │   │   │   ├── KISS.d
│   │   │   │   ├── KissCmwc.d
│   │   │   │   ├── Twister.d
│   │   │   │   └── URandom.d
│   │   │   ├── ExpSource.d
│   │   │   ├── Kiss.d
│   │   │   ├── NormalSource.d
│   │   │   ├── Random.d
│   │   │   ├── Twister.d
│   │   │   └── Ziggurat.d
│   │   ├── Range.d
│   │   ├── SlidingAverage.d
│   │   ├── TimeHistogram.d
│   │   └── WideUInt.d
│   ├── meta
│   │   ├── AliasSeq.d
│   │   ├── codegen
│   │   │   ├── CTFE.d
│   │   │   └── Identifier.d
│   │   ├── traits
│   │   │   ├── Aggregates.d
│   │   │   ├── Aggregates_test.d
│   │   │   ├── Arrays.d
│   │   │   ├── Basic.d
│   │   │   ├── Indirections.d
│   │   │   └── package.d
│   │   ├── types
│   │   │   ├── Arrays.d
│   │   │   ├── Enum.d
│   │   │   ├── Function.d
│   │   │   ├── package.d
│   │   │   ├── Qualifiers.d
│   │   │   ├── ReduceType.d
│   │   │   ├── ReduceType_test.d
│   │   │   ├── Templates.d
│   │   │   └── Typedef.d
│   │   └── values
│   │   ├── Reset.d
│   │   ├── Reset_test.d
│   │   ├── VisitValue.d
│   │   └── VisitValue_test.d
│   ├── net
│   │   ├── collectd
│   │   │   ├── Collectd.d
│   │   │   ├── Identifier.d
│   │   │   └── SocketReader.d
│   │   ├── email
│   │   │   └── EmailSender.d
│   │   ├── http
│   │   │   ├── consts
│   │   │   │   ├── CookieAttributeNames.d
│   │   │   │   ├── HeaderFieldNames.d
│   │   │   │   ├── HttpMethod.d
│   │   │   │   ├── HttpVersion.d
│   │   │   │   ├── StatusCodes.d
│   │   │   │   └── UriDelim.d
│   │   │   ├── cookie
│   │   │   │   ├── CookiesHttpResponse.d
│   │   │   │   ├── HttpCookieGenerator.d
│   │   │   │   └── HttpCookieParser.d
│   │   │   ├── HttpConnectionHandler.d
│   │   │   ├── HttpConst.d
│   │   │   ├── HttpCookies.d
│   │   │   ├── HttpException.d
│   │   │   ├── HttpHeaders.d
│   │   │   ├── HttpParams.d
│   │   │   ├── HttpRequest.d
│   │   │   ├── HttpResponse.d
│   │   │   ├── HttpStack.d
│   │   │   ├── HttpTokens.d
│   │   │   ├── HttpTriplet.d
│   │   │   ├── message
│   │   │   │   ├── HttpHeader.d
│   │   │   │   └── HttpHeaderParser.d
│   │   │   ├── model
│   │   │   │   └── HttpParamsView.d
│   │   │   ├── TaskHttpConnectionHandler.d
│   │   │   └── time
│   │   │   ├── HttpTimeFormatter.d
│   │   │   └── HttpTimeParser.d
│   │   ├── model
│   │   │   └── UriView.d
│   │   ├── server
│   │   │   ├── connection
│   │   │   │   ├── IConnectionHandler.d
│   │   │   │   ├── IConnectionHandlerInfo.d
│   │   │   │   ├── IFiberConnectionHandler.d
│   │   │   │   └── TaskConnectionHandler.d
│   │   │   ├── connpool
│   │   │   │   ├── ISelectListenerPoolInfo.d
│   │   │   │   └── SelectListenerPool.d
│   │   │   ├── SelectListener.d
│   │   │   ├── SelectListener_slowtest.d
│   │   │   └── unix
│   │   │   ├── CommandRegistry.d
│   │   │   ├── UnixConnectionHandler.d
│   │   │   └── UnixListener.d
│   │   ├── ssl
│   │   │   └── SslClientConnection.d
│   │   ├── Uri.d
│   │   └── util
│   │   ├── GetSocketAddress.d
│   │   ├── ParamSet.d
│   │   ├── QueryParams.d
│   │   ├── UrlDecoder.d
│   │   └── UrlEncoder.d
│   ├── stdc
│   │   ├── gnu
│   │   │   └── string.d
│   │   └── posix
│   │   ├── fcntl.d
│   │   ├── gnu
│   │   │   ├── socket.d
│   │   │   └── stdlib.d
│   │   ├── langinfo.d
│   │   ├── netdb.d
│   │   └── sys
│   │   ├── socket.d
│   │   └── un.d
│   ├── sys
│   │   ├── CloseOnExec.d
│   │   ├── CmdPath.d
│   │   ├── Common.d
│   │   ├── CpuAffinity.d
│   │   ├── Environment.d
│   │   ├── Epoll.d
│   │   ├── ErrnoException.d
│   │   ├── EventFD.d
│   │   ├── GetIfAddrs.d
│   │   ├── HomeFolder.d
│   │   ├── Inotify.d
│   │   ├── linux
│   │   │   └── linux.d
│   │   ├── Pipe.d
│   │   ├── Process.d
│   │   ├── SafeFork.d
│   │   ├── SignalFD.d
│   │   ├── SignalMask.d
│   │   ├── socket
│   │   │   ├── AddressIPSocket.d
│   │   │   ├── AddrInfo.d
│   │   │   ├── InetAddress.d
│   │   │   ├── IPSocket.d
│   │   │   ├── model
│   │   │   │   ├── IAddressIPSocketInfo.d
│   │   │   │   └── ISocket.d
│   │   │   └── UnixSocket.d
│   │   ├── stats
│   │   │   └── linux
│   │   │   ├── ProcVFS.d
│   │   │   └── Queriable.d
│   │   ├── Stats.d
│   │   └── TimerFD.d
│   ├── task
│   │   ├── extensions
│   │   │   ├── ExceptionForwarding.d
│   │   │   └── package.d
│   │   ├── internal
│   │   │   ├── FiberPool.d
│   │   │   ├── FiberPoolEager.d
│   │   │   ├── FiberPoolWithQueue.d
│   │   │   ├── SpecializedPools.d
│   │   │   └── TaskExtensionMixins.d
│   │   ├── IScheduler.d
│   │   ├── Scheduler.d
│   │   ├── Scheduler_test.d
│   │   ├── Task.d
│   │   ├── TaskPool.d
│   │   ├── TaskPool_test.d
│   │   ├── ThrottledTaskPool.d
│   │   ├── ThrottledTaskPool_test.d
│   │   └── util
│   │   ├── Event.d
│   │   ├── Event_test.d
│   │   ├── QuickRun.d
│   │   ├── QuickRun_test.d
│   │   ├── StreamProcessor.d
│   │   ├── StreamProcessor_test.d
│   │   ├── TaskPoolSerializer.d
│   │   ├── TaskPoolSerializer_test.d
│   │   ├── TaskSuspender.d
│   │   ├── TaskSuspender_test.d
│   │   ├── Timer.d
│   │   └── Timer_test.d
│   ├── text
│   │   ├── arguments
│   │   │   └── TimeIntervalArgs.d
│   │   ├── Arguments.d
│   │   ├── Ascii.d
│   │   ├── convert
│   │   │   ├── DateTime.d
│   │   │   ├── DateTime_tango.d
│   │   │   ├── Float.d
│   │   │   ├── Float_test.d
│   │   │   ├── Formatter.d
│   │   │   ├── Formatter_test.d
│   │   │   ├── Hash.d
│   │   │   ├── Hex.d
│   │   │   ├── Integer.d
│   │   │   ├── Integer_tango.d
│   │   │   ├── Integer_tango_test.d
│   │   │   ├── TimeStamp.d
│   │   │   ├── UnicodeBom.d
│   │   │   ├── Utf.d
│   │   │   └── Utf_test.d
│   │   ├── csv
│   │   │   ├── CSV.d
│   │   │   └── HeadingsCSV.d
│   │   ├── entities
│   │   │   ├── HtmlEntityCodec.d
│   │   │   ├── HtmlEntitySet.d
│   │   │   ├── model
│   │   │   │   ├── IEntityCodec.d
│   │   │   │   ├── IEntitySet.d
│   │   │   │   └── MarkupEntityCodec.d
│   │   │   ├── XmlEntityCodec.d
│   │   │   └── XmlEntitySet.d
│   │   ├── formatter
│   │   │   └── SmartUnion.d
│   │   ├── json
│   │   │   ├── Json.d
│   │   │   ├── JsonEscape.d
│   │   │   ├── JsonExtractor.d
│   │   │   ├── JsonParser.d
│   │   │   └── JsonParserIter.d
│   │   ├── regex
│   │   │   ├── c
│   │   │   │   └── pcre.d
│   │   │   └── PCRE.d
│   │   ├── Search.d
│   │   ├── Unicode.d
│   │   ├── UnicodeData.d
│   │   ├── utf
│   │   │   ├── c
│   │   │   │   └── glib_unicode.d
│   │   │   ├── GlibUnicode.d
│   │   │   ├── UtfString.d
│   │   │   └── UtfUtil.d
│   │   ├── util
│   │   │   ├── ClassName.d
│   │   │   ├── DigitGrouping.d
│   │   │   ├── EscapeChars.d
│   │   │   ├── MetricPrefix.d
│   │   │   ├── SplitIterator.d
│   │   │   ├── StringC.d
│   │   │   ├── StringEncode.d
│   │   │   ├── StringSearch.d
│   │   │   └── Time.d
│   │   ├── Util.d
│   │   └── xml
│   │   ├── DocEntity.d
│   │   ├── DocPrinter.d
│   │   ├── Document.d
│   │   ├── PullParser.d
│   │   └── SaxParser.d
│   ├── time
│   │   ├── chrono
│   │   │   ├── Calendar.d
│   │   │   ├── Gregorian.d
│   │   │   └── GregorianBased.d
│   │   ├── Clock.d
│   │   ├── ISO8601.d
│   │   ├── MicrosecondsClock.d
│   │   ├── StopWatch.d
│   │   ├── Time.d
│   │   ├── Time_test.d
│   │   ├── timeout
│   │   │   ├── model
│   │   │   │   ├── ExpiryRegistrationBase.d
│   │   │   │   ├── IExpiryRegistration.d
│   │   │   │   ├── ITimeoutClient.d
│   │   │   │   └── ITimeoutManager.d
│   │   │   └── TimeoutManager.d
│   │   └── WallClock.d
│   ├── transition.d
│   └── util
│   ├── aio
│   │   ├── AsyncIO.d
│   │   ├── DelegateJobNotification.d
│   │   ├── EventFDJobNotification.d
│   │   ├── internal
│   │   │   ├── AioScheduler.d
│   │   │   ├── JobQueue.d
│   │   │   ├── MutexOps.d
│   │   │   └── ThreadWorker.d
│   │   ├── JobNotification.d
│   │   └── TaskJobNotification.d
│   ├── app
│   │   ├── Application.d
│   │   ├── CliApp.d
│   │   ├── DaemonApp.d
│   │   ├── ExitException.d
│   │   ├── ext
│   │   │   ├── ArgumentsExt.d
│   │   │   ├── ConfigExt.d
│   │   │   ├── DropPrivilegesExt.d
│   │   │   ├── LogExt.d
│   │   │   ├── model
│   │   │   │   ├── IArgumentsExtExtension.d
│   │   │   │   ├── IConfigExtExtension.d
│   │   │   │   ├── ILogExtExtension.d
│   │   │   │   └── ISignalExtExtension.d
│   │   │   ├── PidLockExt.d
│   │   │   ├── RefuseRootExt.d
│   │   │   ├── ReopenableFilesExt.d
│   │   │   ├── SignalExt.d
│   │   │   ├── StatsExt.d
│   │   │   ├── TaskExt.d
│   │   │   ├── TimerExt.d
│   │   │   ├── UnixSocketExt.d
│   │   │   ├── VersionArgsExt.d
│   │   │   └── VersionInfo.d
│   │   └── model
│   │   ├── ExtensibleClassMixin.d
│   │   ├── IApplication.d
│   │   ├── IApplicationExtension.d
│   │   └── IExtension.d
│   ├── cipher
│   │   ├── gcrypt
│   │   │   ├── AES.d
│   │   │   ├── c
│   │   │   │   ├── gcrypt.d
│   │   │   │   ├── general.d
│   │   │   │   ├── gpgerror.d
│   │   │   │   ├── kdf.d
│   │   │   │   ├── libversion.d
│   │   │   │   ├── md.d
│   │   │   │   └── random.d
│   │   │   ├── core
│   │   │   │   ├── Gcrypt.d
│   │   │   │   ├── KeyDerivationCore.d
│   │   │   │   └── MessageDigestCore.d
│   │   │   ├── HMAC.d
│   │   │   ├── MessageDigest.d
│   │   │   ├── PBKDF2.d
│   │   │   ├── TripleDES.d
│   │   │   └── Twofish.d
│   │   └── misc
│   │   ├── ByteConverter.d
│   │   └── Padding.d
│   ├── compress
│   │   └── c
│   │   ├── Zip.d
│   │   └── zlib.d
│   ├── config
│   │   ├── ConfigFiller.d
│   │   └── ConfigParser.d
│   ├── container
│   │   ├── AppendBuffer.d
│   │   ├── btree
│   │   │   ├── BTreeMap.d
│   │   │   ├── BTreeMapRange.d
│   │   │   └── Implementation.d
│   │   ├── cache
│   │   │   ├── Cache.d
│   │   │   ├── CachingStructLoader.d
│   │   │   ├── CachingStructLoader_test.d
│   │   │   ├── ExpiredCacheReloader.d
│   │   │   ├── ExpiredCacheReloader_test.d
│   │   │   ├── ExpiringCache.d
│   │   │   ├── ExpiringLRUCache.d
│   │   │   ├── LRUCache.d
│   │   │   ├── LRUCache_test.d
│   │   │   ├── model
│   │   │   │   ├── containers
│   │   │   │   │   ├── ArrayPool.d
│   │   │   │   │   ├── KeyToNode.d
│   │   │   │   │   └── TimeToIndex.d
│   │   │   │   ├── ICache.d
│   │   │   │   ├── ICacheInfo.d
│   │   │   │   ├── IExpiringCacheInfo.d
│   │   │   │   ├── ITrackCreateTimesCache.d
│   │   │   │   └── Value.d
│   │   │   └── PriorityCache.d
│   │   ├── CircularList.d
│   │   ├── Clink.d
│   │   ├── ConcatBuffer.d
│   │   ├── Container.d
│   │   ├── ebtree
│   │   │   ├── c
│   │   │   │   ├── eb128tree.d
│   │   │   │   ├── eb32tree.d
│   │   │   │   ├── eb64tree.d
│   │   │   │   ├── ebimtree.d
│   │   │   │   ├── ebistree.d
│   │   │   │   ├── ebmbtree.d
│   │   │   │   ├── ebpttree.d
│   │   │   │   ├── ebsttree.d
│   │   │   │   └── ebtree.d
│   │   │   ├── EBTree128.d
│   │   │   ├── EBTree32.d
│   │   │   ├── EBTree64.d
│   │   │   ├── model
│   │   │   │   ├── IEBTree.d
│   │   │   │   ├── Iterators.d
│   │   │   │   ├── KeylessMethods.d
│   │   │   │   └── Node.d
│   │   │   └── nodepool
│   │   │   └── NodePool.d
│   │   ├── FixedKeyMap.d
│   │   ├── HashRangeMap.d
│   │   ├── HashSet.d
│   │   ├── LinkedList.d
│   │   ├── MallocArray.d
│   │   ├── map
│   │   │   ├── HashMap.d
│   │   │   ├── HashSet.d
│   │   │   ├── Map.d
│   │   │   ├── model
│   │   │   │   ├── Bucket.d
│   │   │   │   ├── BucketElementFreeList.d
│   │   │   │   ├── BucketElementGCAllocator.d
│   │   │   │   ├── BucketElementMallocAllocator.d
│   │   │   │   ├── BucketInfo.d
│   │   │   │   ├── BucketSet.d
│   │   │   │   ├── IAllocator.d
│   │   │   │   ├── IBucketElementGCAllocator.d
│   │   │   │   ├── MapIterator.d
│   │   │   │   └── StandardHash.d
│   │   │   ├── Set.d
│   │   │   ├── TreeMap.d
│   │   │   └── utils
│   │   │   └── MapSerializer.d
│   │   ├── mem
│   │   │   └── MemManager.d
│   │   ├── model
│   │   │   └── IContainer.d
│   │   ├── more
│   │   │   ├── BitSet.d
│   │   │   ├── HashFile.d
│   │   │   ├── Heap.d
│   │   │   ├── Stack.d
│   │   │   └── Vector.d
│   │   ├── pool
│   │   │   ├── AcquiredResources.d
│   │   │   ├── FreeList.d
│   │   │   ├── model
│   │   │   │   ├── IAggregatePool.d
│   │   │   │   ├── IFreeList.d
│   │   │   │   ├── ILimitable.d
│   │   │   │   ├── IPool.d
│   │   │   │   ├── IPoolInfo.d
│   │   │   │   └── IResettable.d
│   │   │   ├── ObjectPool.d
│   │   │   └── StructPool.d
│   │   ├── queue
│   │   │   ├── DynamicQueue.d
│   │   │   ├── FixedRingQueue.d
│   │   │   ├── FlexibleFileQueue.d
│   │   │   ├── FlexibleRingQueue.d
│   │   │   ├── LinkedListQueue.d
│   │   │   ├── model
│   │   │   │   ├── IByteQueue.d
│   │   │   │   ├── IQueue.d
│   │   │   │   ├── IQueueInfo.d
│   │   │   │   ├── IRingQueue.d
│   │   │   │   ├── ITypedQueue.d
│   │   │   │   └── IUntypedQueue.d
│   │   │   ├── NotifyingQueue.d
│   │   │   └── QueueChain.d
│   │   ├── RedBlack.d
│   │   ├── Slink.d
│   │   ├── SortedMap.d
│   │   └── VoidBufferAsArrayOf.d
│   ├── Convert.d
│   ├── DeepReset.d
│   ├── digest
│   │   ├── Crc32.d
│   │   ├── Digest.d
│   │   ├── Md2.d
│   │   ├── Md4.d
│   │   ├── Md5.d
│   │   ├── MerkleDamgard.d
│   │   ├── Ripemd128.d
│   │   ├── Ripemd160.d
│   │   ├── Ripemd256.d
│   │   ├── Ripemd320.d
│   │   ├── Sha0.d
│   │   ├── Sha01.d
│   │   ├── Sha1.d
│   │   ├── Sha256.d
│   │   ├── Sha512.d
│   │   ├── Tiger.d
│   │   └── Whirlpool.d
│   ├── encode
│   │   ├── Base16.d
│   │   ├── Base32.d
│   │   └── Base64.d
│   ├── log
│   │   ├── AppendConsole.d
│   │   ├── Appender.d
│   │   ├── AppendFile.d
│   │   ├── AppendStderrStdout.d
│   │   ├── AppendSysLog.d
│   │   ├── Config.d
│   │   ├── Event.d
│   │   ├── Hierarchy.d
│   │   ├── ILogger.d
│   │   ├── InsertConsole.d
│   │   ├── layout
│   │   │   ├── Date.d
│   │   │   ├── LayoutMessageOnly.d
│   │   │   ├── LayoutSimple.d
│   │   │   └── LayoutStatsLog.d
│   │   ├── Logger.d
│   │   ├── PeriodicTrace.d
│   │   ├── StaticTrace.d
│   │   ├── Stats.d
│   │   ├── Stats_slowtest.d
│   │   └── StatsReader.d
│   ├── prometheus
│   │   ├── collector
│   │   │   ├── Collector.d
│   │   │   ├── CollectorRegistry.d
│   │   │   └── StatFormatter.d
│   │   └── server
│   │   ├── PrometheusHandler.d
│   │   └── PrometheusListener.d
│   ├── ReusableException.d
│   ├── serialize
│   │   ├── contiguous
│   │   │   ├── Contiguous.d
│   │   │   ├── Deserializer.d
│   │   │   ├── MultiVersionDecorator.d
│   │   │   ├── package.d
│   │   │   ├── Serializer.d
│   │   │   └── Util.d
│   │   ├── package.d
│   │   └── Version.d
│   ├── test
│   │   └── DirectorySandbox.d
│   └── uuid
│   ├── NamespaceGenV3.d
│   ├── NamespaceGenV5.d
│   ├── RandomGen.d
│   └── Uuid.d
├── parserinit.d
├── run.sh
├── start.d
├── start.d.cg
├── std
│   ├── algorithm
│   │   ├── comparison.d
│   │   ├── internal.d
│   │   ├── iteration.d
│   │   ├── mutation.d
│   │   ├── searching.d
│   │   ├── setops.d
│   │   └── sorting.d
│   ├── array.d
│   ├── container
│   │   └── rbtree.d
│   ├── format
│   │   ├── internal
│   │   │   ├── floats.d
│   │   │   ├── read.d
│   │   │   └── write.d
│   │   ├── package.d
│   │   ├── read.d
│   │   ├── spec.d
│   │   └── write.d
│   ├── functional.d
│   ├── getopt.d
│   ├── net
│   │   └── curl.d
│   ├── regex
│   │   ├── internal
│   │   │   └── tests.d
│   │   └── package.d
│   ├── sumtype.d
│   ├── typecons.d
│   └── variant.d
└── undead
├── bitarray.d
├── cstream.d
├── database.d
├── date.d
├── dateparse.d
├── doformat.d
├── metastrings.d
├── regexp.d
├── signals.d
├── stream.d
├── string.d
├── utf.d
└── xml.d
146 directories, 713 files
Raw
out.txt
HOST_DMD=
MODEL=64
ENABLE_RELEASE=
ENABLE_DEBUG=
DFLAGS=
clean dmd
(RM) P:\dmd\generated\windows\release\64
Success
build dmd
(TX) SYSCONFDIR
(DC) COMMON
(TX) VERSION
(TX) DMD_CONF
(DC) BACKEND
(DC) LEXER
(DC) DMD
Success
copy
start.d
testdfa\start.d(236): Error: Variable `ptr` was required to be non-null and has become null
foreach (i; 0 .. 2)
^
testdfa\start.d(257): Error: Variable `ptr` was required to be non-null and has become null
foreach (i; 0 .. 2)
^
testdfa\start.d(308): Error: Dereference on null variable `ptr`
int v = *ptr; // error
^
testdfa\start.d(330): Error: Dereference on null variable `ptr`
int v = *ptr; // error
^
testdfa\start.d(613): Error: Assert can be proven to be false
assert(val); // Error: val is 0
^
testdfa\start.d(619): Error: Assert can be proven to be false
assert(stack.length == 1); // Error: stack is null
^
testdfa\start.d(673): Error: Dereference on null variable `ptr`
return *ptr; // error could be null
^
testdfa\start.d(703): Error: Assert can be proven to be false
assert(ptr !is null); // error
^
extracted.d
dmd
dmd-unit
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): Deprecation: `__traits(getAttributes)` may only be used for individual functions, not the overload set `executeTest`
alias getUDAs = Filter!(isDesiredUDA!attribute, __traits(getAttributes, symbol));
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): the result of `__traits(getOverloads)` may be used to select the desired function to extract attributes from
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): Deprecation: `__traits(getAttributes)` may only be used for individual functions, not the overload set `executeTest`
alias getUDAs = Filter!(isDesiredUDA!attribute, __traits(getAttributes, symbol));
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): the result of `__traits(getOverloads)` may be used to select the desired function to extract attributes from
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): Deprecation: `__traits(getAttributes)` may only be used for individual functions, not the overload set `toString`
alias getUDAs = Filter!(isDesiredUDA!attribute, __traits(getAttributes, symbol));
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): the result of `__traits(getOverloads)` may be used to select the desired function to extract attributes from
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): Deprecation: `__traits(getAttributes)` may only be used for individual functions, not the overload set `toString`
alias getUDAs = Filter!(isDesiredUDA!attribute, __traits(getAttributes, symbol));
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\phobos\std\traits.d(8642): the result of `__traits(getOverloads)` may be used to select the desired function to extract attributes from
dmd\backend\arm\cod1.d(958): Error: Assert can be proven to be false
assert(e1free);
^
dmd\backend\x86\cgxmm.d(485): Error: Assert can be proven to be false
assert(op != NoOpcode);
^
run dmd-unit
test.d(1): Error: declaration expected following attribute, not end of file
test.d(2): Error: declaration expected following attribute, not end of file
test.d(4): Error: declaration expected following attribute, not end of file
test.d(1): Error: declaration expected following attribute, not end of file
test.d(2): Error: declaration expected following attribute, not end of file
test.d(4): Error: declaration expected following attribute, not end of file
test.d(1): Error: declaration expected following attribute, not end of file
test.d(2): Error: declaration expected following attribute, not end of file
test.d(4): Error: declaration expected following attribute, not end of file
test.d(3): Error: declaration expected following attribute, not end of file
test.d(1): Error: declaration expected following attribute, not end of file
test.d(2): Error: declaration expected following attribute, not end of file
test.d(4): Error: declaration expected following attribute, not end of file
test.d(3): Error: declaration expected following attribute, not end of file
test.d(1): Error: declaration expected following attribute, not end of file
test.d(2): Error: declaration expected following attribute, not end of file
test.d(4): Error: declaration expected following attribute, not end of file
test.d(3): Error: declaration expected following attribute, not end of file
test.d(1): Error: declaration expected following attribute, not end of file
test.d(1): Error: declaration expected following attribute, not end of file
test.d(1): Error: unexpected identifier `f` after `void`
test.d(1): Error: semicolon expected to close `alias` declaration, not `(`
test.d(1): Error: declaration expected, not `)`
test.d(1): Error: character constant has multiple characters
test.d(2): Error: character constant has multiple characters
Hello
Assert is provably false at test.d(2)
[Tuple!(string, Kind)("object", private_), Tuple!(string, Kind)("std.stdio", public_), Tuple!(string, Kind)("std.file", private_)]
345 tests, 0 failures
libraries
xtest46
Boo!double
Boo!int
true
int
!! immutable(int)[]
int(int i, long j = 7L)
long
C10390(C10390(<recursion>))
AliasSeq!(height)
AliasSeq!(get, get)
AliasSeq!(clear)
AliasSeq!(draw, draw)
const(int)
string[]
double[]
double[]
..\test\runnable\xtest46.d(2588): Error: Assert can be proven to be false
assert(s);
^
{}
AliasSeq!("m")
true
TFunction1: extern (C) void function()
xtest46_gc
Boo!double
Boo!int
true
int
!! immutable(int)[]
int(int i, long j = 7L)
long
C10390(C10390(<recursion>))
AliasSeq!(height)
AliasSeq!(get, get)
AliasSeq!(clear)
AliasSeq!(draw, draw)
const(int)
string[]
double[]
double[]
..\test\runnable\xtest46_gc.d-mixin-30(2617): Error: Assert can be proven to be false
assert(s);
^
{}
AliasSeq!("m")
true
TFunction1: extern (C) void function()
runnable/interpret.d
true
g
&Test109S(&Test109S(<recursion>))
tfoo
tfoo
Crash!
runnable/testdstress.d
runnable/complex.d
..\test\runnable\complex.d(59): Deprecation: use of complex type `cdouble[1]` is deprecated, use `std.complex.Complex!(double)` instead
cdouble[1] a3;
^
..\test\runnable\complex.d(60): Deprecation: use of complex type `cdouble[1]` is deprecated, use `std.complex.Complex!(double)` instead
cdouble[1] b3;
^
..\test\runnable\complex.d(80): Deprecation: use of complex type `creal[1]` is deprecated, use `std.complex.Complex!(real)` instead
creal[1] a4;
^
..\test\runnable\complex.d(81): Deprecation: use of complex type `creal[1]` is deprecated, use `std.complex.Complex!(real)` instead
creal[1] b4;
^
..\test\runnable\complex.d(134): Deprecation: use of complex type `creal[1]` is deprecated, use `std.complex.Complex!(real)` instead
creal[1] a8;
^
..\test\runnable\complex.d(135): Deprecation: use of complex type `creal[1]` is deprecated, use `std.complex.Complex!(real)` instead
creal[1] b8;
^
..\test\runnable\complex.d(155): Deprecation: use of complex type `creal[1]` is deprecated, use `std.complex.Complex!(real)` instead
creal[1] a9;
^
..\test\runnable\complex.d(156): Deprecation: use of complex type `creal[1]` is deprecated, use `std.complex.Complex!(real)` instead
creal[1] b9;
^
..\test\runnable\complex.d(334): Deprecation: use of complex type `cfloat[]` is deprecated, use `std.complex.Complex!(float)` instead
__gshared cfloat[] a8966;
^
..\test\runnable\complex.d(564): Deprecation: use of complex type `cdouble` is deprecated, use `std.complex.Complex!(double)` instead
cdouble y23;
^
..\test\runnable\complex.d(835): Deprecation: use of imaginary type `ireal` is deprecated, use `real` instead
ireal x35;
^
..\test\runnable\complex.d(1065): Deprecation: use of complex type `creal` is deprecated, use `std.complex.Complex!(real)` instead
creal x55;
^
..\test\runnable\complex.d(1167): Deprecation: use of imaginary type `ireal` is deprecated, use `real` instead
alias typeof(BUG3919.init*BUG3919.init) ICE3919;
^
..\test\runnable\complex.d(1167): Deprecation: use of imaginary type `ireal` is deprecated, use `real` instead
alias typeof(BUG3919.init*BUG3919.init) ICE3919;
^
..\test\runnable\complex.d(1168): Deprecation: use of imaginary type `ireal` is deprecated, use `real` instead
alias typeof(BUG3919.init/BUG3919.init) ICE3920;
^
..\test\runnable\complex.d(1168): Deprecation: use of imaginary type `ireal` is deprecated, use `real` instead
alias typeof(BUG3919.init/BUG3919.init) ICE3920;
^
..\test\runnable\complex.d(1268): Deprecation: use of complex type `cdouble` is deprecated, use `std.complex.Complex!(double)` instead
cdouble val;
^
..\test\runnable\complex.d(44): Deprecation: use of imaginary type `ireal` is deprecated, use `real` instead
ireal f2() { return 1i; }
^
..\test\runnable\complex.d(48): Deprecation: use of complex type `creal` is deprecated, use `std.complex.Complex!(real)` instead
creal v = 0+0i;
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\array\concatenation.d(20): Deprecation: use of complex type `cdouble[1]` is deprecated, use `std.complex.Complex!(double)` instead
Tret _d_arraycatnTX(Tret, Tarr...)(auto ref Tarr froms) @trusted
^
924 deprecation warnings omitted, use `-verrors=0` to show all
runnable/testtypeid.d
runnable/test_cdstrpar.d
curl
phobos
testdfa/std/array.d
testdfa/std/functional.d
testdfa/std/getopt.d
testdfa/std/sumtype.d
testdfa/std/typecons.d
testdfa/std/variant.d
testdfa/std/algorithm/comparison.d
testdfa/std/algorithm/internal.d
testdfa/std/algorithm/iteration.d
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa/std/algorithm/mutation.d
testdfa/std/algorithm/searching.d
testdfa/std/algorithm/setops.d
testdfa/std/algorithm/sorting.d
testdfa/std/container/rbtree.d
testdfa/std/format/package.d
testdfa/std/format/read.d
testdfa/std/format/spec.d
testdfa/std/format/write.d
testdfa/std/net/curl.d
testdfa/std/regex/package.d
testdfa/std/format/internal/floats.d
testdfa/std/format/internal/read.d
testdfa/std/format/internal/write.d
testdfa/std/regex/internal/tests.d
phobos-all
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
testdfa\std\typecons.d(1269): Deprecation: `@safe` function `toHash` calling `hashOf`
const k = .hashOf(field[i]);
^
P:\ProjectSidero\dmd2\windows\bin\..\..\src\druntime\import\core\internal\hash.d-mixin-562(652): and accessing overlapped field `ChunkByGroup.mothership` with pointers makes it fail to infer `@safe`
h = hashOf(val.tupleof[i].tupleof[0], h);
^
ocean
There will be no gc stats! You need to use dmd transitional:
https://github.com/sociomantic-tsunami/dmd-transitional
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(int) nothrow @nogc)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
testdfa\ocean\sys\ErrnoException.d(166): instantiated from here: `Caller!(extern (C) int function(int) nothrow @nogc)`
public Caller!(typeof(&Func)) enforceRet (alias Func) (
^
testdfa\ocean\sys\Inotify.d(157): instantiated from here: `enforceRet!(inotify_init1)`
this.fd = this.e.enforceRet!(inotify_init1)(&verify)
^
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(int, const(char)*, uint) nothrow @nogc)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
testdfa\ocean\sys\ErrnoException.d(166): instantiated from here: `Caller!(extern (C) int function(int, const(char)*, uint) nothrow @nogc)`
public Caller!(typeof(&Func)) enforceRet (alias Func) (
^
testdfa\ocean\sys\Inotify.d(200): instantiated from here: `enforceRet!(inotify_add_watch)`
return cast(uint) this.e.enforceRet!(.inotify_add_watch)(&verify)
^
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(int, uint) nothrow @nogc)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
testdfa\ocean\sys\ErrnoException.d(166): instantiated from here: `Caller!(extern (C) int function(int, uint) nothrow @nogc)`
public Caller!(typeof(&Func)) enforceRet (alias Func) (
^
testdfa\ocean\sys\Inotify.d(219): instantiated from here: `enforceRet!(inotify_rm_watch)`
return cast(uint) this.e.enforceRet!(.inotify_rm_watch)(&verify).call(this.fd, wd);
^
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(int, int) nothrow @nogc)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
testdfa\ocean\sys\ErrnoException.d(166): instantiated from here: `Caller!(extern (C) int function(int, int) nothrow @nogc)`
public Caller!(typeof(&Func)) enforceRet (alias Func) (
^
testdfa\ocean\sys\TimerFD.d(117): instantiated from here: `enforceRet!(timerfd_create)`
this.fd = this.e.enforceRet!(Upstream.timerfd_create)(&verify).call(
^
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(int, itimerspec*) nothrow @nogc)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
testdfa\ocean\sys\ErrnoException.d(232): instantiated from here: `Caller!(extern (C) int function(int, itimerspec*) nothrow @nogc)`
public Caller!(typeof(&Func)) enforceRetCode (alias Func) (
^
testdfa\ocean\sys\TimerFD.d(171): instantiated from here: `enforceRetCode!(timerfd_gettime)`
this.e.enforceRetCode!(Upstream.timerfd_gettime)().call(this.fd, &t);
^
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(int, int, const(itimerspec*), itimerspec*) nothrow @nogc)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
testdfa\ocean\sys\ErrnoException.d(232): instantiated from here: `Caller!(extern (C) int function(int, int, const(itimerspec*), itimerspec*) nothrow @nogc)`
public Caller!(typeof(&Func)) enforceRetCode (alias Func) (
^
testdfa\ocean\sys\TimerFD.d(203): instantiated from here: `enforceRetCode!(timerfd_settime)`
this.e.enforceRetCode!(Upstream.timerfd_settime)().call(
^
testdfa\ocean\meta\types\Function.d(120): Error: Dereference on null variable `call`
return call(args);
^
testdfa\ocean\sys\ErrnoException.d(401): Error: template instance `ocean.meta.types.Function.ReturnTypeOf!(extern (C) int function(pthread_mutex_t*, pthread_mutexattr_t*) nothrow @nogc @trusted)` error instantiating
private bool function (ReturnTypeOf!(T)) verify;
^
error limit (20) reached, use `-verrors=0` to show all
Raw
run.sh
case 2 in
0)
# detect OOM and stack overflow issues
export MODEL=32
;;
1)
# performance test
export HOST_DMD=ldmd2
export MODEL=64
export ENABLE_RELEASE=1
export ENABLE_DEBUG=1
#export DFLAGS="-O3 -mcpu=native"
;;
2)
# Normal build
export MODEL=64
;;
3)
export MODEL=32
export HOST_DMD=ldmd2
export ENABLE_RELEASE=1
export ENABLE_DEBUG=1
export DFLAGS="-O3 -mcpu=native"
#export DFLAGS="--fsanitize=address --link-internally -L/FORCE -L/STACK:67108864"
;;
*)
;;
esac
export DRUNTIME_PATH="P:\\ProjectSidero\\dmd2\\src\\druntime\\import"
export PHOBOS_PATH="P:\\ProjectSidero\\dmd2\\src\\phobos"
echo "HOST_DMD="$HOST_DMD
echo "MODEL="$MODEL
echo "ENABLE_RELEASE="$ENABLE_RELEASE
echo "ENABLE_DEBUG="$ENABLE_DEBUG
echo "DFLAGS="$DFLAGS
[ ! -e /cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd.exe ] || rm /cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd.exe
echo "clean dmd"
rdmd build.d clean
echo "build dmd"
rdmd build.d --force DFLAGS="$DFLAGS"
if [[ $? != 0 ]]; then
exit $?
fi
echo "copy"
cp ../../generated/windows/release/$MODEL/dmd.exe /cygdrive/p/ProjectSidero/dmd2/windows/bin/
if [[ $? != 0 ]]; then
exit $?
fi
#if false; then
echo "start.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem testdfa/start.d
#exit 0
echo "extracted.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -c testdfa/extracted.d
#exit 0
echo "dmd"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -c -debug \
-J../.. -Jdmd/res \
-Idmd dmd/root/*.d dmd/common/*.d \
"dmd/console.d" \
"dmd/entity.d" \
"dmd/errors.d" \
"dmd/file_manager.d" \
"dmd/globals.d" \
"dmd/id.d" \
"dmd/identifier.d" \
"dmd/lexer.d" \
"dmd/location.d" \
"dmd/sarif.d" \
"dmd/tokens.d" \
"dmd/utils.d" \
"dmd/errorsink.d" \
"dmd/astbase.d" \
"dmd/parse.d" \
"dmd/visitor/transitive.d" \
"dmd/visitor/permissive.d" \
"dmd/visitor/strict.d" \
"testdfa/parserinit"
#exit 0
#fi
echo "dmd-unit"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem \
-version=NoBackend -version=GC -version=NoMain -version=MARS -version=DMDLIB \
-g -unittest -J../.. -Jdmd/res \
-Isrc -I../test/unit -i -main \
../test/unit/*/*.d ../test/unit/*/*/*.d \
-of=runner.exe ../test/test_results/runner.d
echo "run dmd-unit"
./runner.exe
#exit 0
echo "libraries"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -main \
testdfa/demangle.d testdfa/json.d testdfa/errno.c testdfa/file.d testdfa/event.d testdfa/undead/*.d
echo "xtest46"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -Jrunnable -preview=rvaluerefparam -J../test/runnable ../test/runnable/xtest46.d
echo "xtest46_gc"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -Jrunnable -preview=rvaluerefparam -J../test/runnable ../test/runnable/xtest46_gc.d
echo "runnable/interpret.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -preview=rvaluerefparam ../test/runnable/interpret.d
echo "runnable/testdstress.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -preview=rvaluerefparam ../test/runnable/testdstress.d
echo "runnable/complex.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -preview=rvaluerefparam ../test/runnable/complex.d
echo "runnable/testtypeid.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -preview=rvaluerefparam ../test/runnable/testtypeid.d
echo "runnable/test_cdstrpar.d"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -preview=rvaluerefparam ../test/runnable/test_cdstrpar.d
echo "curl"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -main -Itestdfa \
-w -preview=dip1000 -preview=dtorfields -preview=fieldwise -m32 -O -release -unittest -version=StdUnittest \
testdfa/std/net/curl.d
#exit 0
echo "phobos"
for phobosFile in testdfa/std/*.d testdfa/std/*/*.d testdfa/std/*/*/*.d; do
echo $phobosFile
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -main -w -debug -g -unittest -version=StdUnittest \
-preview=dip1000 -preview=dtorfields -preview=fieldwise -Itestdfa $phobosFile
done;
#fi
echo "phobos-all"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -lowmem -main -w -debug -g -unittest -version=StdUnittest \
-preview=dip1000 -preview=dtorfields -preview=fieldwise -lowmem -Itestdfa testdfa/std/*.d testdfa/std/*/*.d testdfa/std/*/*/*.d
#fi
echo "ocean"
/cygdrive/p/ProjectSidero/dmd2/windows/bin/dmd -preview=fastdfa -c -o- -os=linux -m64 -lowmem -Jrunnable -Itestdfa \
testdfa/ocean/*.d testdfa/ocean/*/*.d testdfa/ocean/*/*/*.d testdfa/ocean/*/*/*/*.d \
testdfa/ocean/*/*/*/*/*.d testdfa/ocean/*/*/*/*/*/*.d
Raw
start.d
import core.stdc.stdio;
@safe:
int main()
{
int a;
int b;
int c;
if (c)
{
a = 9;
}
else
{
b = 22;
}
assert(c); // Error: c is false
return 2;
}
bool isNull1(int* ptr)
{
return ptr is null;
}
void isNull2()
{
int* ptr;
if (ptr !is null)
{
int v = *ptr; // Will not error due to the null test
}
else
{
}
}
bool truthinessYes()
{
return true;
}
bool truthinessNo()
{
return false;
}
int* nullable1(int* ptr)
{
int* ret;
if (truthinessYes())
{
}
else
{
ret = ptr;
}
int v = *ret; // ideally would error, but not required
return ret;
}
void nullable2a(S2* head, S2* previous)
{
S2* start;
{
S2* current;
if (start is null)
{
previous = head;
start = previous;
current = start.next;
}
else
{
current = start.next;
}
previous = current.next; // should not error
}
}
void nullable2b(S2* start, S2* head, S2* previous)
{
{
S2* current;
if (start is null)
{
previous = head;
start = previous;
current = start.next;
}
else
{
current = start.next;
}
previous = current.next; // should not error
}
}
void nullable3(S2** nextParent, S2* r)
{
if (*nextParent is null)
*nextParent = r; // should not error
}
void nullable4(int* temp) @trusted
{
int buffer;
if (temp is null)
temp = &buffer;
int v = *temp; // should not error
}
int nonnull1(int* ptr)
{
return *ptr;
}
void truthiness1()
{
bool a = true;
assert(a != false);
assert(a == !false);
bool b = !a, c = a != false, d = a == false;
}
struct S1
{
int* field;
}
struct S2
{
S2* next;
S2* another;
}
void trackS1(S1 s)
{
bool b = s.field !is null;
}
void branchCheck()
{
bool val;
if (false)
{
val = true;
}
}
void loopy()
{
int j;
Loop: foreach (i; 0 .. 10)
{
j += i * j;
if (j > 5)
continue;
else if (j > 6)
break;
}
}
void loopy2()
{
Loop: do
{
}
while (false);
}
void loopy3()
{
ReadLoopConsole: for (;;)
{
}
}
void loopy4()
{
Loop1: foreach (i; 0 .. 10)
{
break Loop1;
}
Loop2: foreach (i; 0 .. 10)
{
continue Loop2;
}
}
void loopy5()
{
Loop: foreach (i; 0 .. 4)
{
switch (i)
{
case 0:
break;
case 1:
continue;
case 2:
continue Loop;
default:
break Loop;
}
}
}
void loopy6()
{
int* ptr = new int;
foreach (i; 0 .. 2)
{
int val = *ptr;
ptr = null; // error
}
}
void loopy7()
{
int* ptr = new int;
foreach (i; 0 .. 2)
{
if (ptr !is null)
int val1 = *ptr; // ok
ptr = null;
}
ptr = new int;
foreach (i; 0 .. 2)
{
if (ptr !is null)
int val1 = *ptr; // ok
int val2 = *ptr; // error
ptr = null;
}
}
void loopy8()
{
int* ptr = new int;
bool b = ptr !is null;
foreach (i; 0 .. 2)
{
assert(b); // outdated consequences
ptr = null; // error
}
}
void loopy9(int[] input)
{
bool result;
foreach (val; input)
{
if (val == 1)
result = true;
}
assert(result);
}
void loop10(bool match, uint[] testCases)
{
foreach (tc; testCases)
{
bool failure;
if (!match)
failure = true;
assert(!failure);
}
}
void nested1()
{
static void nested2()
{
int* ptr;
int v = *ptr; // error
}
int* ptr;
void nested3()
{
int v = *ptr;
}
nested2;
nested3;
}
void theSitch(int arg)
{
bool passedBy;
switch (arg)
{
case 0:
int* ptr;
int v = *ptr; // error
goto default;
case 1:
return;
default:
if (passedBy)
goto case 1;
passedBy = true;
goto case 0;
}
}
void theSitchFinally()
{
{
goto Label;
}
{
Label:
}
int* ptr;
scope (exit)
int vS = *ptr;
int vMid = *ptr;
truthinessNo;
}
void nodeFind()
{
static struct Node
{
Node* next;
static Node* previous;
}
Node* start = Node.previous;
Node* current;
if (start is null)
{
start = Node.previous;
current = start.next;
}
else
current = start.next;
Node.previous = current.next;
}
void referenceThat() @trusted
{
int[2] val;
int* ptr = &val[1];
}
void logicalAnd(bool b, int* ptr)
{
bool a = true;
if (a && b && ptr !is null)
{
}
}
void logicalOr(bool b, int* ptr)
{
bool a = true;
if ((a && b) || ptr !is null)
{
int val = *ptr;
}
}
void rotateForChildren(void** parent)
{
if (*parent is null)
return;
}
void removeValue(S2* valueNode)
{
if (valueNode.another !is null)
valueNode.next.next = valueNode.next;
if (valueNode.next.next is valueNode)
valueNode.next.next = valueNode.another;
else
valueNode.next.another = valueNode.another;
}
void goingByRef1(ref int* ptr)
{
ptr = new int;
}
void goingByRef2(ref int* ptr)
{
if (ptr is null)
ptr = new int;
}
void goingByRef3(ref int* ptr)
{
if (*ptr == 3)
ptr = new int;
}
void aaWrite1()
{
string[string] env;
env["MYVAR1"] = "first";
env["MYVAR2"] = "second";
assert(env["MYVAR1"] == "first");
}
void aaWrite2()
{
struct Wrapper
{
string[string] env;
}
Wrapper* wrapper = new Wrapper;
wrapper.env["MYVAR1"] = "first";
wrapper.env["MYVAR2"] = "second";
}
void lengthChange()
{
int[] test;
test.length = 10;
assert(test.length == 10);
assert(test.ptr != null);
test.length = 1;
assert(test.length == 1);
assert(test.ptr != null);
test = test[5 .. 5];
test.length = 0;
assert(test.length == 0);
assert(test.ptr != null);
}
void callLaterEffect1() @system
{
static struct Thing
{
int* data;
~this()
{
(*data)++;
}
}
int val;
scope (exit)
assert(val == 1);
Thing thing = Thing(&val);
}
void callLaterEffect2() @system
{
static struct Thing
{
int* data;
~this()
{
(*data)++;
}
}
int val;
Thing thing = Thing(&val);
val = 0;
assert(val == 1);
}
void callByRefEffect() @system
{
static void effect(Args...)(auto ref Args args)
{
args[0] = -1;
}
int val;
effect(val);
assert(val == 1);
}
struct SkippableType
{
bool a, b, c, d;
}
bool skipItIf(SkippableType* i, SkippableType** o)
{
*o = i;
return true;
}
void skippedNot(SkippableType* token) @system
{
SkippableType* storage;
if (token.a || token.b || skipItIf(token, &storage) && (storage.a
|| storage.b) || (token.c || token.d))
{
}
}
void indexAA()
{
struct MyStruct
{
int x;
}
int[MyStruct] td;
td[MyStruct(10)] = 4;
assert(td[MyStruct(10)] == 4);
assert(MyStruct(20) !in td);
assert(td[MyStruct(10)] == 4);
}
void dupMatch()
{
static ubyte[] copy(ubyte[] input)
{
return input;
}
struct Escape
{
ubyte[] array;
}
ubyte[] reference = new ubyte[20];
ubyte[] another = copy(reference);
Escape escape = Escape(another[0 .. 0]);
assert(reference[] == another[]);
}
void classCall() @trusted
{
class C
{
this(int* val)
{
*val = 1;
}
void method() @safe
{
}
}
int anInt;
C c = new C(&anInt);
assert(anInt == 2);
c.method;
}
void assertNoCompare()
{
int val;
assert(val); // Error: val is 0
}
void vectorExp()
{
string[] stack;
assert(stack.length == 1); // Error: stack is null
}
void unknownLoopIterationCount()
{
bool[] res;
while (auto value = truthinessYes())
res ~= value;
assert(res == [1, 2, 3]);
}
struct OrAndIndirect
{
OrAndIndirect* left_, right_;
int val;
OrAndIndirect* left()
{
return left_;
}
OrAndIndirect* right()
{
return right_;
}
OrAndIndirect* orAndIndirect(OrAndIndirect* w)
{
OrAndIndirect* wl = w.left;
OrAndIndirect* wr = w.right;
if ((wl is null || wl.val == 0) && (wr is null || wr.val == 0))
{
}
else
{
if (wr is null || wr.val == 0)
{
wl.val = 0;
}
}
return null;
}
}
int nullSet(int* ptr, bool gate)
{
if (ptr !is null)
{
if (gate)
ptr = null;
return *ptr; // error could be null
}
return -1;
}
void gateUpgrade(bool gate)
{
int* ptr;
if (gate)
{
ptr = new int;
}
if (gate)
{
assert(ptr !is null); // no error
}
}
void gateDowngrade(bool gate, int* ptr)
{
if (gate)
{
ptr = null;
}
if (gate)
{
assert(ptr !is null); // error
}
}
void checkCompare(string input)
{
if (input == "^^")
return;
char c = input[0];
}
void incrementEffect()
{
int[] array;
assert(array.length++ == 0);
assert(array.length == 1);
}
void unknownArrayLiteralCall() @trusted
{
int toCall(int* ptr)
{
return *ptr;
}
int val;
int[] literal = [toCall(&val)];
assert(val == 0);
}
void branchKill(bool b)
{
assert(!b);
if (b)
{
int* ptr;
int val = *ptr; // no error branch dead
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment