Add tests for "knr" brace style.
This commit is contained in:
Sönke Ludwig
parent
e35bde0815
commit
0f61586438
|
|
@ -0,0 +1,37 @@
|
|||
unittest {
|
||||
targets = [
|
||||
[
|
||||
RectangleShape.create(tex, vec2(-8 * scale, -32 * scale),
|
||||
vec2(16 * scale, 48 * scale), vec4(14 / 16.0, 0, 16 / 16.0, 3 / 16.0)),
|
||||
RectangleShape.create(tex, vec2(-8 * scale, -32 * scale),
|
||||
vec2(16 * scale, 32 * scale), vec4(14 / 16.0, 3 / 16.0, 16 / 16.0, 5 / 16.0))
|
||||
],
|
||||
[
|
||||
RectangleShape.create(tex, vec2(-8 * scale, -8 * scale),
|
||||
vec2(16 * scale, 16 * scale), vec4(14 / 16.0, 5 / 16.0, 15 / 16.0, 6 / 16.0)),
|
||||
RectangleShape.create(tex, vec2(-8 * scale, -8 * scale),
|
||||
vec2(16 * scale, 16 * scale), vec4(15 / 16.0, 5 / 16.0, 16 / 16.0, 6 / 16.0))
|
||||
]
|
||||
];
|
||||
|
||||
int[][] foo = [
|
||||
[
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
|
||||
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
|
||||
],
|
||||
[
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
|
||||
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
|
||||
]
|
||||
];
|
||||
|
||||
float[3][3] mat = [
|
||||
[234.3456, 42435.8653, 23.5], [3.245, 235.3, 234.664],
|
||||
[14324.6453, 23434.645, 9678.345]
|
||||
];
|
||||
}
|
||||
|
||||
string[][] globalArray = [
|
||||
["123456789012345678901234567890", "123456789012345678901234567890"],
|
||||
["123456789012345678901234567890", "123456789012345678901234567890"]
|
||||
];
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
import std.stdio;
|
||||
|
||||
class Foo {
|
||||
}
|
||||
|
||||
import std.conv;
|
||||
|
||||
void main()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
const baz = 11;
|
||||
class Foo2 : Foo {
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
unittest {
|
||||
foo([
|
||||
target.value.region[1], target.value.region[1],
|
||||
target.value.region[1], target.value.region[1], target.value.region[1]
|
||||
]);
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
void main()
|
||||
{
|
||||
string key;
|
||||
|
||||
int[string] var = [
|
||||
key: 5
|
||||
];
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
unittest {
|
||||
Bson base = Bson([
|
||||
"maps": Bson([
|
||||
Bson(["id": Bson(4), "comment": Bson("hello")]),
|
||||
Bson(["id": Bson(49), "comment": Bson(null)])
|
||||
]),
|
||||
"short": Bson(["a": "b", "c": "d"]),
|
||||
"numbers": Bson([
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
|
||||
]),
|
||||
"shuffleOnReset": serializeToBson([
|
||||
"all": false,
|
||||
"selected": true,
|
||||
"maybe": false
|
||||
]),
|
||||
"resetOnEmpty": Bson(false),
|
||||
"applyMods": Bson(true),
|
||||
"sendComments": Bson(true)
|
||||
]);
|
||||
int[] x = [
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3,
|
||||
4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
|
||||
];
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
auto find()
|
||||
{
|
||||
return Map.findRange([
|
||||
"$and": [
|
||||
["deleted": Bson(false)],
|
||||
[
|
||||
"$or": Bson([
|
||||
serializeToBson(["forceUpdate": Bson(true)]),
|
||||
serializeToBson([
|
||||
"info.approved": ["$eq": Bson(1)],
|
||||
"fetchDate": [
|
||||
"$lte": Bson(BsonDate(currentTime - 60.days))
|
||||
]
|
||||
]),
|
||||
serializeToBson([
|
||||
"info.approved": ["$ne": Bson(1)],
|
||||
"fetchDate": [
|
||||
"$lte": Bson(BsonDate(currentTime - 14.days))
|
||||
]
|
||||
])
|
||||
])
|
||||
]
|
||||
]
|
||||
]);
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
struct SomeStructName {
|
||||
static struct InnerStruct {
|
||||
version (linux) {
|
||||
static if (condition) {
|
||||
void longFunctionName(AAAAAAAA)(AAAAAAAA a) @property
|
||||
if (someThingsAreTrue!AAAAAAAA && long_condition
|
||||
&& is(elaborate == expression))
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
unittest {
|
||||
{
|
||||
{
|
||||
foreach (abcde, def; abcdef.map!(battlecruiser => battlecruiser[123 .. 1231231])
|
||||
.filter!(bravo => charlie[10] > 90000)
|
||||
.sum()) {
|
||||
|
||||
}
|
||||
abcdeabcdeabcde(12341234).abcdeabcdeabcde(12341234).abcdeabcdeabcde(12341234)
|
||||
.abcdeabcdeabcde(12341234).abcdeabcdeabcde(12341234);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
class U0 : Exception {
|
||||
this() @safe pure nothrow
|
||||
{
|
||||
super("U0 error message");
|
||||
}
|
||||
}
|
||||
|
||||
class U1 : Exception {
|
||||
this() @safe pure nothrow
|
||||
{
|
||||
super("U1 error message");
|
||||
}
|
||||
}
|
||||
|
||||
void foo()
|
||||
{
|
||||
import std.stdio;
|
||||
|
||||
foreach (immutable i; 0 .. 2) {
|
||||
try {
|
||||
i.bar;
|
||||
} catch (U0) {
|
||||
"Function foo caught exception U0".writeln;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void bar(in int i) @safe pure
|
||||
{
|
||||
i.baz;
|
||||
}
|
||||
|
||||
void baz(in int i) @safe pure
|
||||
{
|
||||
throw i ? new U1 : new U0;
|
||||
}
|
||||
|
||||
void main()
|
||||
{
|
||||
foo;
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
int /*sneaky*/ foo( /*comments*/ ) /*everywhere*/
|
||||
{
|
||||
// comment on its own line
|
||||
foo() // comment on same line
|
||||
.bar(); // also on same line
|
||||
/* again */ // same line
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
void foo()()
|
||||
if (dogs && pigs && birds && ants && foxes && flies && cats && bugs && bees
|
||||
&& cows && sheeps && monkeys && whales)
|
||||
{
|
||||
}
|
||||
|
||||
void foo()() if (dogs && pigs && birds)
|
||||
{
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
void foo()()
|
||||
if (dogs && pigs && birds && ants && foxes && flies && cats && bugs && bees
|
||||
&& cows && sheeps && monkeys && whales)
|
||||
{
|
||||
}
|
||||
|
||||
void foo()()
|
||||
if (dogs && pigs && birds)
|
||||
{
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
void main(string[] args)
|
||||
{
|
||||
struct SomeStruct {
|
||||
private:
|
||||
int a;
|
||||
int b;
|
||||
void doStuff(int q)
|
||||
in {
|
||||
assert(q);
|
||||
}
|
||||
out (result) {
|
||||
}
|
||||
body {
|
||||
writeln(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
void main()
|
||||
{
|
||||
if (true)
|
||||
debug {
|
||||
foo();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
void main()
|
||||
{
|
||||
debug (0)
|
||||
foo();
|
||||
else
|
||||
bar();
|
||||
}
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
int foo(int arg)
|
||||
in {
|
||||
assert(arg > 0);
|
||||
}
|
||||
out (result) {
|
||||
assert(result == 0);
|
||||
}
|
||||
do {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bar(int arg)
|
||||
in (arg > 0)
|
||||
out (; true)
|
||||
out /*Major*/ ( /*Tom*/ result /*To ground control*/ ; result == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
import character.body;
|
||||
|
||||
void body() @nogc
|
||||
in {
|
||||
}
|
||||
body {
|
||||
body = null;
|
||||
}
|
||||
|
||||
void body()
|
||||
in {
|
||||
}
|
||||
do {
|
||||
body = null;
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
enum Foo {
|
||||
|
||||
deprecated member0,
|
||||
@UDA(0) member1
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
// Computes average line length for standard input.
|
||||
import std.stdio;
|
||||
|
||||
void main()
|
||||
{
|
||||
ulong lines = 0;
|
||||
double sumLength = 0;
|
||||
foreach (line; stdin.byLine()) {
|
||||
++lines;
|
||||
sumLength += line.length;
|
||||
}
|
||||
writeln("Average line length: ", lines ? sumLength / lines : 0);
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
void foo(@UDA(0) @UDA(1) Bar bar);
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
import std.stdio, std.random, std.typecons, std.conv, std.string, std.range;
|
||||
|
||||
void main()
|
||||
{
|
||||
immutable interval = tuple(1, 100);
|
||||
writefln("Guess my target number that is between " ~ "%d and %d (inclusive).\n", interval[]);
|
||||
immutable target = uniform!"[]"(interval[]);
|
||||
|
||||
foreach (immutable i; sequence!q{n}) {
|
||||
writef("Your guess #%d: ", i + 1);
|
||||
immutable txt = stdin.readln.strip;
|
||||
|
||||
Nullable!int answer;
|
||||
try {
|
||||
answer = txt.to!int;
|
||||
} catch (ConvException e) {
|
||||
writefln(" I don't understand your input '%s'", txt);
|
||||
continue;
|
||||
}
|
||||
if (answer < interval[0] || answer > interval[1]) {
|
||||
writeln(" Out of range!");
|
||||
continue;
|
||||
}
|
||||
if (answer == target) {
|
||||
writeln(" Well guessed.");
|
||||
break;
|
||||
}
|
||||
writeln(answer < target ? " Too low." : " Too high.");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
import std.stdio;
|
||||
|
||||
void main()
|
||||
{
|
||||
writeln("Hello, world without explicit compilations!");
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
int hof(int a, int b, int delegate(int, int) f)
|
||||
{
|
||||
return f(a, b);
|
||||
}
|
||||
|
||||
void main()
|
||||
{
|
||||
import std.stdio;
|
||||
|
||||
writeln("Add: ", hof(2, 3, (a, b) => a + b));
|
||||
writeln("Multiply: ", hof(2, 3, (a, b) => a * b));
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
immutable NameId[] namesA = [
|
||||
{"Aacgr", 0x00386}, // GREEK CAPITAL LETTER ALPHA WITH TONOS
|
||||
{"aacgr", 0x003AC}, // GREEK SMALL LETTER ALPHA WITH TONOS
|
||||
];
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
import core.stdc.ctype;
|
||||
|
||||
/*********************************************
|
||||
*
|
||||
*/
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
void func()
|
||||
{
|
||||
if (!negative)
|
||||
return this;
|
||||
else if (a.negative)
|
||||
return max();
|
||||
else
|
||||
return a.value == 0 ? a : this;
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
struct X {
|
||||
~this()
|
||||
{
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
string generateFixedLengthCases()
|
||||
{
|
||||
int[] shortList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
|
||||
something[] items = [
|
||||
one, two, three, four, five, six, seven, eight, nine, ten, eleven,
|
||||
twelve, thirteen, fourteen
|
||||
];
|
||||
|
||||
string[] fixedLengthTokens = [
|
||||
"abstract", "alias", "align", "asm", "assert", "auto", "body", "bool",
|
||||
"break", "byte", "case", "cast", "catch", "cdouble", "cent", "cfloat",
|
||||
"char", "class", "const", "continue", "creal", "dchar", "debug", "default",
|
||||
"delegate", "delete", "deprecated", "do", "double", "else", "enum",
|
||||
"export", "extern", "false", "final", "finally", "float", "for", "foreach",
|
||||
"foreach_reverse", "function", "goto", "idouble", "if", "ifloat",
|
||||
"immutable", "import", "in", "inout", "int", "interface", "invariant",
|
||||
"ireal", "is", "lazy", "long", "macro", "mixin", "module", "new",
|
||||
"nothrow", "null", "out", "override", "package", "pragma", "private",
|
||||
"protected", "public", "pure", "real", "ref", "return", "scope", "shared",
|
||||
"short", "static", "struct", "super", "switch", "synchronized", "template",
|
||||
"this", "throw", "true", "try", "typedef", "typeid", "typeof", "ubyte",
|
||||
"ucent", "uint", "ulong", "union", "unittest", "ushort", "version", "void",
|
||||
"volatile", "wchar", "while", "with", "__DATE__", "__EOF__",
|
||||
"__FILE__", "__FUNCTION__", "__gshared", "__LINE__",
|
||||
"__MODULE__", "__parameters", "__PRETTY_FUNCTION__", "__TIME__",
|
||||
"__TIMESTAMP__", "__traits", "__vector", "__VENDOR__", "__VERSION__",
|
||||
",", ".", "..", "...", "/", "/=", "!", "!<", "!<=", "!<>", "!<>=",
|
||||
"!=", "!>", "!>=", "$", "%", "%=", "&", "&&", "&=", "(", ")", "*",
|
||||
"*=", "+", "++", "+=", "-", "--", "-=", ":", ";", "<", "<<", "<<=",
|
||||
"<=", "<>", "<>=", "=", "==", "=>", ">", ">=", ">>", ">>=", ">>>",
|
||||
">>>=", "?", "@", "[", "]", "^", "^=", "^^", "^^=", "{", "|", "|=", "||",
|
||||
"}", "~", "~="
|
||||
];
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
complex_t opMul_r(real x)
|
||||
{
|
||||
return complex_t(x) * this;
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
complex_t opMul(real y)
|
||||
{
|
||||
return this * complex_t(y);
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
extern (C++) int HtmlNamedEntity(const(char)* p, size_t length);
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
SignExtendedNumber opMul(const SignExtendedNumber a) const
|
||||
{
|
||||
// like 0x10 * 0x10 == 0x100 == 0.
|
||||
|
||||
/* Special handling for zeros:
|
||||
*/
|
||||
}
|
||||
|
||||
unittest {
|
||||
if (Port.isNan(r1) || Port.isNan(r2)) // if unordered
|
||||
{
|
||||
}
|
||||
|
||||
while (cur && cur.ty == Tsarray) // sizes of dimensions
|
||||
{
|
||||
TypeSArray sa = cast(TypeSArray) cur;
|
||||
mangleNumber(sa.dim ? sa.dim.toInteger() : 0);
|
||||
cur = cur.nextOf();
|
||||
}
|
||||
|
||||
if (fd) {
|
||||
/* Use storage_class2 instead of storage_class otherwise when we do .di generation
|
||||
* we'll wind up with 'const const' rather than 'const'.
|
||||
*/
|
||||
/* Don't think we need to worry about mutually exclusive storage classes here
|
||||
*/
|
||||
fd.storage_class2 |= stc;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
SignExtendedNumber opMul(const SignExtendedNumber a) const
|
||||
{
|
||||
/* Special handling for zeros:
|
||||
*/
|
||||
|
||||
// like 0x10 * 0x10 == 0x100 == 0.
|
||||
}
|
||||
|
||||
// Because int64_t and friends may be any integral type of the
|
||||
// correct size, we have to explicitly ask for the correct
|
||||
// integer type to get the correct mangling with ddmd
|
||||
|
||||
// Be careful not to care about sign when using dinteger_t
|
||||
// use this instead of integer_t to
|
||||
// avoid conflicts with system #include's
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
unittest {
|
||||
if (imin.value > 0x10FFFFUL) // ??
|
||||
imin.value = 0x10FFFFUL; // ??
|
||||
with (stuff) switch (a) {
|
||||
case a:
|
||||
doStuff();
|
||||
break;
|
||||
}
|
||||
switch (a) {
|
||||
}
|
||||
if (something) /** whatever */
|
||||
doStuff();
|
||||
if (something) /+ comment +/ {
|
||||
doStuff();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
unittest {
|
||||
char** buf = cast(char**) mem.xmalloc(dim * (char*).sizeof);
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
unittest {
|
||||
tolower(*p);
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
import std.stdio : writeln;
|
||||
|
||||
void main()
|
||||
{
|
||||
writeln(cast(dchar)uint.max);
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
SignExtendedNumber opSub(const SignExtendedNumber a) const
|
||||
{
|
||||
if (a.isMinimum())
|
||||
return negative ? SignExtendedNumber(value, false) : max();
|
||||
else
|
||||
return this + (-a);
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
static IntRange fromType(Type type, bool isUnsigned)
|
||||
{
|
||||
if (type.toBasetype().ty == Tdchar)
|
||||
upper.value = 0x10FFFFUL;
|
||||
else if (!isUnsigned) {
|
||||
lower.value = ~(mask >> 1);
|
||||
lower.value = ~(mask >> 1);
|
||||
lower.negative = true;
|
||||
upper.value = (mask >> 1);
|
||||
}
|
||||
uinteger_t minHalfChunk = imin.value & ~halfChunkMask;
|
||||
uinteger_t maxHalfChunk = imax.value & ~halfChunkMask;
|
||||
return IntRange(lower, upper);
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
unittest {
|
||||
if (a.value == 0) {
|
||||
if (a.negative)
|
||||
return SignExtendedNumber(value == 0 && negative);
|
||||
else
|
||||
return extreme(negative);
|
||||
}
|
||||
|
||||
uinteger_t aAbs = copySign(a.value, a.negative);
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
unittest {
|
||||
if (some_very_long_expression && some_very_long_expression &&
|
||||
some_very_long_expression && some_very_long_expression && some_very_long_expression) {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
class U {
|
||||
private:
|
||||
unittest {
|
||||
Label:
|
||||
int a = 0;
|
||||
}
|
||||
}
|
||||
|
||||
unittest {
|
||||
loop: while (true) {
|
||||
doStuff();
|
||||
}
|
||||
Label: {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
static int isInfinity(double r)
|
||||
{
|
||||
auto a = r is double.infinity || r is -double.infinity;
|
||||
auto b = r is double.infinity || r !is -double.infinity;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
version (AArch64) int x = 10;
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
static if (is(typeof(T.init.apply(fp, null)))) {
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
unittest {
|
||||
version (Windows)
|
||||
__locale_decpoint = save;
|
||||
}
|
||||
|
||||
unittest {
|
||||
version (Windows)
|
||||
__locale_decpoint = save;
|
||||
else
|
||||
__locale_decpoint = save;
|
||||
version (Win32) int x;
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
unittest {
|
||||
switch (something) with (stuff) {
|
||||
case 1:
|
||||
case 2:
|
||||
label:
|
||||
doStuff();
|
||||
case 3: .. case 4:
|
||||
doOtherStuff();
|
||||
goto label;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
enum Sizeok : int {
|
||||
SIZEOKnone, // size of aggregate is not computed yet
|
||||
SIZEOKdone, // size of aggregate is set correctly
|
||||
SIZEOKfwd, // error in computing size of aggregate
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
void doStuff()
|
||||
{
|
||||
for (;;) {
|
||||
}
|
||||
for (size_t i = 0; i < se.len;) {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
class C {
|
||||
void func()
|
||||
{
|
||||
switch (x) {
|
||||
default:
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
void main(string[] args)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
unittest {
|
||||
|
||||
FuncDeclaration* pFd = cast(FuncDeclaration*) dmd_aaGet(&arrayfuncs, cast(void*) ident);
|
||||
FuncDeclaration fd = *pFd;
|
||||
{
|
||||
auto dd = new DtorDeclaration(declLoc, Loc(), stc, Identifier.idPool("__fieldDtor"));
|
||||
auto dd = new DtorDeclaration(declLoc, Loc(), stc, extraParam,
|
||||
midLengthFun(param, param), longIdentifier, Identifier.idPool("__fieldDtor"));
|
||||
|
||||
memcpy(&saved_idents, &rvl.saved_idents, (const(char)*).sizeof * VC_SAVED_IDENT_CNT);
|
||||
memcpy(&saved_types, &rvl.saved_types, (Type).sizeof * VC_SAVED_TYPE_CNT);
|
||||
|
||||
auto ed = new EnumDeclaration(loc, ident, memtype ? memtype.syntaxCopy() : null);
|
||||
}
|
||||
}
|
||||
|
||||
void doStuff(const Token[] tokens, ref const State current,
|
||||
const FormatterConfig* formatterConfig, int currentLineLength, int indentLevel, int depth)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
unittest {
|
||||
if (x) {
|
||||
if (y) {
|
||||
auto z = doCond(e.thisexp) || doCond(e.newargs) || doCond(e.arguments) || applyTo(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
@Shortcut("[shift] + [tab]")
|
||||
@MenuItem("Text/Decrease")
|
||||
void textDecreaseIndent(BufferView v)
|
||||
{
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
void main(string[] args)
|
||||
{
|
||||
switch (value) {
|
||||
case 0:
|
||||
return null;
|
||||
case 1:
|
||||
// Indented comment
|
||||
/* fall through */
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
void fun()
|
||||
{
|
||||
if (something)
|
||||
foreach (_; 0 .. 100)
|
||||
if (true) {
|
||||
if (stuff)
|
||||
doStuff();
|
||||
else
|
||||
morestuff();
|
||||
} else
|
||||
doStuff();
|
||||
|
||||
cast(structalign_t) 1;
|
||||
for (*cost = 0; sc; sc = sc.enclosing, (*cost)++)
|
||||
if (sc.scopesym == scopesym)
|
||||
break;
|
||||
else
|
||||
a++;
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
void f()
|
||||
{
|
||||
if (a) {
|
||||
} else // wat
|
||||
{
|
||||
if (!is_temp_arg_ref) {
|
||||
if (global.params.isOSX)
|
||||
buf.writeByte('_');
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
enum Flags : int {
|
||||
IS_NOT_TOP_TYPE = 0x1,
|
||||
MANGLE_RETURN_TYPE = 0x2,
|
||||
IGNORE_CONST = 0x4,
|
||||
IS_DMC = 0x8,
|
||||
}
|
||||
|
||||
auto a = [b, c, d,];
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
enum DYNCAST : int {
|
||||
DYNCAST_OBJECT,
|
||||
DYNCAST_EXPRESSION,
|
||||
DYNCAST_DSYMBOL,
|
||||
DYNCAST_TYPE,
|
||||
DYNCAST_IDENTIFIER,
|
||||
DYNCAST_TUPLE,
|
||||
DYNCAST_PARAMETER,
|
||||
}
|
||||
|
||||
alias MATCHnomatch = MATCH.MATCHnomatch;
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
struct ClassFlags {
|
||||
alias Type = uint;
|
||||
enum Enum : int {
|
||||
isCOMclass = 0x1,
|
||||
noPointers = 0x2,
|
||||
hasOffTi = 0x4,
|
||||
hasCtor = 0x8,
|
||||
hasGetMembers = 0x10,
|
||||
hasTypeInfo = 0x20,
|
||||
isAbstract = 0x40,
|
||||
isCPPclass = 0x80,
|
||||
hasDtor = 0x100,
|
||||
|
||||
}
|
||||
|
||||
alias isCOMclass = Enum.isCOMclass;
|
||||
alias noPointers = Enum.noPointers;
|
||||
alias hasOffTi = Enum.hasOffTi;
|
||||
alias hasCtor = Enum.hasCtor;
|
||||
alias hasGetMembers = Enum.hasGetMembers;
|
||||
alias hasTypeInfo = Enum.hasTypeInfo;
|
||||
alias isAbstract = Enum.isAbstract;
|
||||
alias isCPPclass = Enum.isCPPclass;
|
||||
alias hasDtor = Enum.hasDtor;
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
unittest {
|
||||
{
|
||||
{
|
||||
}
|
||||
}
|
||||
{
|
||||
}
|
||||
{
|
||||
{
|
||||
{
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
~this()
|
||||
{
|
||||
}
|
||||
|
||||
extern (C++) ~this()
|
||||
{
|
||||
global.gag = oldgag;
|
||||
}
|
||||
|
||||
struct S {
|
||||
public ~this()
|
||||
{
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
/********************************************************
|
||||
* Helper function for checkAccess()
|
||||
* Returns:
|
||||
* false is not accessible
|
||||
* true is accessible
|
||||
*/
|
||||
extern (C++) static bool isAccessible()
|
||||
{
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
extern (C++) FuncDeclaration buildXopEquals(StructDeclaration sd, Scope* sc)
|
||||
{
|
||||
if (!needOpEquals(sd))
|
||||
return null; // bitwise comparison would work
|
||||
//printf("StructDeclaration::buildXopEquals() %s\n", sd->toChars());
|
||||
if (Dsymbol eq = search_function(sd, Id.eq)) {
|
||||
if (FuncDeclaration fd = eq.isFuncDeclaration()) {
|
||||
TypeFunction tfeqptr;
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
static if (a) {
|
||||
} else static if (b) {
|
||||
} else {
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
const(char)*[VC_SAVED_IDENT_CNT] saved_idents;
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
unittest {
|
||||
switch (op) {
|
||||
return -1; // memory blocks are different
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
import ddmd.aggregate, ddmd.backend, ddmd.dclass, ddmd.declaration,
|
||||
ddmd.dmodule, ddmd.dsymbol, ddmd.dtemplate, ddmd.expression, ddmd.func,
|
||||
ddmd.globals, ddmd.identifier, ddmd.init, ddmd.mtype, ddmd.root.array,
|
||||
ddmd.root.file, ddmd.root.rootobject, ddmd.statement;
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
unittest {
|
||||
return true; //
|
||||
Lnomatch:
|
||||
//printf("nomatch\n");
|
||||
return false; // nomatch;
|
||||
}
|
||||
|
||||
unittest {
|
||||
if (x)
|
||||
return true;
|
||||
}
|
||||
|
||||
unittest {
|
||||
return true; // match
|
||||
Lnomatch: //printf("nomatch\n");
|
||||
return false; // nomatch;
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
void main(string[] args)
|
||||
{
|
||||
if ((*tempdecl.parameters)[i].isTemplateThisParameter() is null) {
|
||||
}
|
||||
if (a() in b || a() is b) {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
int overloadApply(int function(void*, Dsymbol) fp)
|
||||
{
|
||||
}
|
||||
|
||||
void takesArray(int[])
|
||||
{
|
||||
doesntUseArray();
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
alias Key = void*;
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
version (all) {
|
||||
} else version (none) {
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
unittest {
|
||||
if (0) {
|
||||
L1:
|
||||
if (0) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
unittest {
|
||||
if (0)
|
||||
if (0) {
|
||||
something();
|
||||
something_else();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
void presumed(out uint column) @trusted
|
||||
{
|
||||
CXString cxstring;
|
||||
|
||||
clang_getPresumedLocation(cx, &cxstring, &line, &column);
|
||||
filename = toD(cxstring);
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
@property bool isFunctionType()
|
||||
{
|
||||
with (CXTypeKind)
|
||||
return kind == CXType_FunctionNoProto || kind == CXType_FunctionProto
|
||||
|| // FIXME: This "hack" shouldn't be needed.
|
||||
func.resultType.isValid;
|
||||
}
|
||||
|
||||
@property bool isFunctionPointerType()
|
||||
{
|
||||
with (CXTypeKind)
|
||||
return kind == CXType_Pointer && pointeeType.isFunctionType;
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
unittest {
|
||||
Label:
|
||||
while (1) {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
unittest {
|
||||
switch (x) {
|
||||
case a: {
|
||||
}
|
||||
case b:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
unittest {
|
||||
switch (x) {
|
||||
case a:
|
||||
return;
|
||||
version (A) {
|
||||
case b:
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
unittest {
|
||||
if (0)
|
||||
if (0) {
|
||||
} else if (0) {
|
||||
} else {
|
||||
}
|
||||
doSomething();
|
||||
}
|
||||
|
||||
unittest {
|
||||
if (0)
|
||||
if (0) {
|
||||
}
|
||||
doSomething();
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
unittest {
|
||||
label:
|
||||
if (x) {
|
||||
}
|
||||
Label:
|
||||
|
||||
// comment
|
||||
statement();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
bool contains(T item)
|
||||
{
|
||||
asm pure nothrow @nogc {
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
alias T = typeof(return);
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
unittest {
|
||||
if (a)
|
||||
if (b)
|
||||
doSomething();
|
||||
doSomethingElse();
|
||||
}
|
||||
|
||||
void indent()
|
||||
{
|
||||
import std.range : repeat, take;
|
||||
|
||||
if (config.useTabs)
|
||||
foreach (i; 0 .. indentLevel + tempIndent) {
|
||||
currentLineLength += config.tabSize;
|
||||
output.put("\t");
|
||||
} else
|
||||
foreach (i; 0 .. indentLevel + tempIndent)
|
||||
foreach (j; 0 .. config.indentSize) {
|
||||
output.put(" ");
|
||||
currentLineLength++;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
unittest {
|
||||
switch (x) {
|
||||
case +1:
|
||||
case -1:
|
||||
case (1):
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
unittest {
|
||||
if (x)
|
||||
doSomething();
|
||||
//doSomethingElse();
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
unittest {
|
||||
L1:
|
||||
switch (x) {
|
||||
case Case:
|
||||
doSomething();
|
||||
doSomethingElse();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
unittest {
|
||||
switch (x) {
|
||||
version (none) {
|
||||
x();
|
||||
case Case:
|
||||
doSomething();
|
||||
doSomethingElse();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
unittest {
|
||||
switch (cast(uint) sz) {
|
||||
case 3:
|
||||
if (!global.params.is64bit)
|
||||
goto Lmemory;
|
||||
case 4:
|
||||
t1 = Type.tint32;
|
||||
break;
|
||||
case 5:
|
||||
if (!global.params.is64bit)
|
||||
goto Lmemory;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
unittest {
|
||||
if (x) {
|
||||
version (none) {
|
||||
} else {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
void test()
|
||||
{
|
||||
fun((int x) { writeln(x); }, (int x) { writeln(x); });
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
unittest {
|
||||
if (!fdmatch)
|
||||
goto Lfd;
|
||||
{
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
version (Windows) void func();
|
||||
version (Windows)
|
||||
void func();
|
||||
else
|
||||
void func();
|
||||
version (Windows) {
|
||||
void func();
|
||||
}
|
||||
version (Windows) {
|
||||
void func();
|
||||
} else {
|
||||
void func();
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
unittest {
|
||||
switch (x) {
|
||||
case 0:
|
||||
version (none) {
|
||||
// Comment
|
||||
case '\n':
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unittest {
|
||||
switch (x) {
|
||||
case 0: {
|
||||
Label: while (1) {
|
||||
}
|
||||
break;
|
||||
}
|
||||
Label2:
|
||||
doStuff();
|
||||
}
|
||||
}
|
||||
|
||||
unittest {
|
||||
switch (a) {
|
||||
case a:
|
||||
doStuff();
|
||||
doOtherStuff();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
unittest {
|
||||
if (!fdmatch)
|
||||
goto Lfd; // comment
|
||||
{
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
unittest {
|
||||
if (a) {
|
||||
if (b)
|
||||
if (c) {
|
||||
if (excessivelyLongVariableName.longAttributeName
|
||||
&& excessivelyLongVariableName.longAttributeName
|
||||
&& excessivelyLongVariableName.longAttributeName)
|
||||
excessivelyLongFunctionName(true);
|
||||
else {
|
||||
excessivelyLongFunctionName(false);
|
||||
}
|
||||
} else
|
||||
a();
|
||||
}
|
||||
}
|
||||
|
||||
unittest {
|
||||
if (a) {
|
||||
if (b) {
|
||||
if (c) {
|
||||
if (excessivelyLongVariableName.longAttributeName
|
||||
&& excessivelyLongVariableName.longAttributeName
|
||||
&& excessivelyLongVariableName.longAttributeName)
|
||||
excessivelyLongFunctionName(true);
|
||||
else {
|
||||
excessivelyLongFunctionName(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
unittest {
|
||||
loop: while (i < tokens.length) switch (tokens[i].type) {
|
||||
case tok!"(":
|
||||
parenDepth++;
|
||||
i++;
|
||||
break;
|
||||
case tok!"{":
|
||||
braceDepth++;
|
||||
i++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
#! /usr/bin/env rdmd
|
||||
|
||||
import std.stdio : writeln;
|
||||
|
||||
int main(immutable string[] args)
|
||||
{
|
||||
writeln("Hello World!");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
import std.stdio: stderr;
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue