Add tests for "knr" brace style.

tests/knr/2d_arrays.d.ref

@@ -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"]
+];

tests/knr/DeclSpacing.d.ref

@@ -0,0 +1,15 @@
+import std.stdio;
+
+class Foo {
+}
+
+import std.conv;
+
+void main()
+{
+    return;
+}
+
+const baz = 11;
+class Foo2 : Foo {
+}

tests/knr/array_access.d.ref

@@ -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]
+            ]);
+}

tests/knr/assoc_key_indent.d.ref

@@ -0,0 +1,8 @@
+void main()
+{
+    string key;
+
+    int[string] var = [
+        key: 5
+    ];
+}

tests/knr/associative_array.d.ref

@@ -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
+    ];
+}

tests/knr/associative_array_complex.d.ref

@@ -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))
+                                ]
+                            ])
+                        ])
+                ]
+            ]
+            ]);
+}

tests/knr/attribute_constraint.d.ref

@@ -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))
+                {
+                }
+            }
+        }
+    }
+}

tests/knr/breakOnDots.d.ref

@@ -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);
+        }
+    }
+}

tests/knr/catchExceptionNested.d.ref

@@ -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;
+}

tests/knr/comments.d.ref

@@ -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
+}

tests/knr/constraint_singe_tab.d.ref

@@ -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)
+{
+}

tests/knr/constraint_singe_tab2.d.ref

@@ -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)
+{
+}

tests/knr/contracts.d.ref

@@ -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);
+        }
+    }
+}

tests/knr/debug-inside-if.d.ref

@@ -0,0 +1,7 @@
+void main()
+{
+    if (true)
+        debug {
+            foo();
+        }
+}

tests/knr/debug_with_param.d.ref

@@ -0,0 +1,7 @@
+void main()
+{
+    debug (0)
+        foo();
+    else
+        bar();
+}

tests/knr/dip1009.d.ref

@@ -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;
+}

tests/knr/do_body.d.ref

@@ -0,0 +1,15 @@
+import character.body;
+
+void body() @nogc
+in {
+}
+body {
+    body = null;
+}
+
+void body()
+in {
+}
+do {
+    body = null;
+}

tests/knr/enum_attribs.d.ref

@@ -0,0 +1,5 @@
+enum Foo {
+
+    deprecated member0,
+    @UDA(0) member1
+}

tests/knr/frontpage.d.ref

@@ -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);
+}

tests/knr/func_param_attrib.d.ref

@@ -0,0 +1 @@
+void foo(@UDA(0) @UDA(1) Bar bar);

tests/knr/guessnumber.d.ref

@@ -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.");
+    }
+}

tests/knr/hello.d.ref

@@ -0,0 +1,6 @@
+import std.stdio;
+
+void main()
+{
+    writeln("Hello, world without explicit compilations!");
+}

tests/knr/higherorder.d.ref

@@ -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));
+}

tests/knr/issue0017.d.ref

@@ -0,0 +1,4 @@
+immutable NameId[] namesA = [
+    {"Aacgr", 0x00386}, // GREEK CAPITAL LETTER ALPHA WITH TONOS
+    {"aacgr", 0x003AC}, // GREEK SMALL LETTER ALPHA WITH TONOS
+];

tests/knr/issue0018.d.ref

@@ -0,0 +1,5 @@
+import core.stdc.ctype;
+
+/*********************************************
+ *
+ */

tests/knr/issue0021.d.ref

@@ -0,0 +1,9 @@
+void func()
+{
+    if (!negative)
+        return this;
+    else if (a.negative)
+        return max();
+    else
+        return a.value == 0 ? a : this;
+}

tests/knr/issue0022.d.ref

@@ -0,0 +1,5 @@
+struct X {
+    ~this()
+    {
+    }
+}

tests/knr/issue0023.d.ref

@@ -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__",
+        ",", ".", "..", "...", "/", "/=", "!", "!<", "!<=", "!<>", "!<>=",
+        "!=", "!>", "!>=", "$", "%", "%=", "&", "&&", "&=", "(", ")", "*",
+        "*=", "+", "++", "+=", "-", "--", "-=", ":", ";", "<", "<<", "<<=",
+        "<=", "<>", "<>=", "=", "==", "=>", ">", ">=", ">>", ">>=", ">>>",
+        ">>>=", "?", "@", "[", "]", "^", "^=", "^^", "^^=", "{", "|", "|=", "||",
+        "}", "~", "~="
+    ];
+
+}

tests/knr/issue0024.d.ref

@@ -0,0 +1,4 @@
+complex_t opMul_r(real x)
+{
+    return complex_t(x) * this;
+}

tests/knr/issue0025.d.ref

@@ -0,0 +1,4 @@
+complex_t opMul(real y)
+{
+    return this * complex_t(y);
+}

tests/knr/issue0026.d.ref

@@ -0,0 +1 @@
+extern (C++) int HtmlNamedEntity(const(char)* p, size_t length);

tests/knr/issue0027.d.ref

@@ -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

tests/knr/issue0028.d.ref

@@ -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();
+    }
+}

tests/knr/issue0029.d.ref

@@ -0,0 +1,3 @@
+unittest {
+    char** buf = cast(char**) mem.xmalloc(dim * (char*).sizeof);
+}

tests/knr/issue0030.d.ref

@@ -0,0 +1,3 @@
+unittest {
+    tolower(*p);
+}

tests/knr/issue0031.d.ref

@@ -0,0 +1,6 @@
+import std.stdio : writeln;
+
+void main()
+{
+    writeln(cast(dchar)uint.max);
+}

tests/knr/issue0032.d.ref

@@ -0,0 +1,7 @@
+SignExtendedNumber opSub(const SignExtendedNumber a) const
+{
+    if (a.isMinimum())
+        return negative ? SignExtendedNumber(value, false) : max();
+    else
+        return this + (-a);
+}

tests/knr/issue0033.d.ref

@@ -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);
+}

tests/knr/issue0034.d.ref

@@ -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);
+}

tests/knr/issue0035.d.ref

@@ -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) {
+    }
+}

tests/knr/issue0037.d.ref

@@ -0,0 +1,15 @@
+class U {
+private:
+    unittest {
+    Label:
+        int a = 0;
+    }
+}
+
+unittest {
+    loop: while (true) {
+        doStuff();
+    }
+Label: {
+    }
+}

tests/knr/issue0038.d.ref

@@ -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;
+}

tests/knr/issue0039.d.ref

@@ -0,0 +1 @@
+version (AArch64) int x = 10;

tests/knr/issue0041.d.ref

@@ -0,0 +1,2 @@
+static if (is(typeof(T.init.apply(fp, null)))) {
+}

tests/knr/issue0042.d.ref

@@ -0,0 +1,12 @@
+unittest {
+    version (Windows)
+        __locale_decpoint = save;
+}
+
+unittest {
+    version (Windows)
+        __locale_decpoint = save;
+    else
+        __locale_decpoint = save;
+    version (Win32) int x;
+}

tests/knr/issue0043.d.ref

@@ -0,0 +1,13 @@
+unittest {
+    switch (something) with (stuff) {
+    case 1:
+    case 2:
+    label:
+        doStuff();
+    case 3: .. case 4:
+        doOtherStuff();
+        goto label;
+    default:
+        break;
+    }
+}

tests/knr/issue0044.d.ref

@@ -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
+}

tests/knr/issue0045.d.ref

@@ -0,0 +1,7 @@
+void doStuff()
+{
+    for (;;) {
+    }
+    for (size_t i = 0; i < se.len;) {
+    }
+}

tests/knr/issue0046.d.ref

@@ -0,0 +1,13 @@
+class C {
+    void func()
+    {
+        switch (x) {
+        default:
+            assert(0);
+        }
+    }
+
+    void main(string[] args)
+    {
+    }
+}

tests/knr/issue0047.d.ref

@@ -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);
+        }
+    }
+}

tests/knr/issue0048.d.ref

@@ -0,0 +1,5 @@
+@Shortcut("[shift] + [tab]")
+@MenuItem("Text/Decrease")
+void textDecreaseIndent(BufferView v)
+{
+}

tests/knr/issue0049.d.ref

@@ -0,0 +1,11 @@
+void main(string[] args)
+{
+    switch (value) {
+    case 0:
+        return null;
+    case 1:
+        // Indented comment
+        /* fall through */
+    default:
+    }
+}

tests/knr/issue0050.d.ref

@@ -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++;
+}

tests/knr/issue0051.d.ref

@@ -0,0 +1,12 @@
+void f()
+{
+    if (a) {
+    } else // wat
+    {
+        if (!is_temp_arg_ref) {
+            if (global.params.isOSX)
+                buf.writeByte('_');
+        }
+    }
+    return;
+}

tests/knr/issue0052.d.ref

@@ -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,];

tests/knr/issue0053.d.ref

@@ -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;

tests/knr/issue0054.d.ref

@@ -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;
+
+}

tests/knr/issue0056.d.ref

@@ -0,0 +1,16 @@
+unittest {
+    {
+        {
+        }
+    }
+    {
+    }
+    {
+        {
+            {
+                {
+                }
+            }
+        }
+    }
+}

tests/knr/issue0057.d.ref

@@ -0,0 +1,14 @@
+~this()
+{
+}
+
+extern (C++) ~this()
+{
+    global.gag = oldgag;
+}
+
+struct S {
+    public ~this()
+    {
+    }
+}

tests/knr/issue0058.d.ref

@@ -0,0 +1,9 @@
+/********************************************************
+ * Helper function for checkAccess()
+ * Returns:
+ *      false   is not accessible
+ *      true    is accessible
+ */
+extern (C++) static bool isAccessible()
+{
+}

tests/knr/issue0059.d.ref

@@ -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;
+            {
+            }
+        }
+    }
+}

tests/knr/issue0060.d.ref

@@ -0,0 +1,4 @@
+static if (a) {
+} else static if (b) {
+} else {
+}

tests/knr/issue0061.d.ref

@@ -0,0 +1 @@
+const(char)*[VC_SAVED_IDENT_CNT] saved_idents;

tests/knr/issue0062.d.ref

@@ -0,0 +1,5 @@
+unittest {
+    switch (op) {
+        return -1; // memory blocks are different
+    }
+}

tests/knr/issue0063.d.ref

@@ -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;

tests/knr/issue0064.d.ref

@@ -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;
+}

tests/knr/issue0065.d.ref

@@ -0,0 +1,7 @@
+void main(string[] args)
+{
+    if ((*tempdecl.parameters)[i].isTemplateThisParameter() is null) {
+    }
+    if (a() in b || a() is b) {
+    }
+}

tests/knr/issue0066.d.ref

@@ -0,0 +1,8 @@
+int overloadApply(int function(void*, Dsymbol) fp)
+{
+}
+
+void takesArray(int[])
+{
+    doesntUseArray();
+}

tests/knr/issue0067.d.ref

@@ -0,0 +1 @@
+alias Key = void*;

tests/knr/issue0068.d.ref

@@ -0,0 +1,3 @@
+version (all) {
+} else version (none) {
+}

tests/knr/issue0069.d.ref

@@ -0,0 +1,7 @@
+unittest {
+    if (0) {
+    L1:
+        if (0) {
+        }
+    }
+}

tests/knr/issue0070.d.ref

@@ -0,0 +1,7 @@
+unittest {
+    if (0)
+        if (0) {
+            something();
+            something_else();
+        }
+}

tests/knr/issue0073.d.ref

@@ -0,0 +1,7 @@
+void presumed(out uint column) @trusted
+{
+    CXString cxstring;
+
+    clang_getPresumedLocation(cx, &cxstring, &line, &column);
+    filename = toD(cxstring);
+}

tests/knr/issue0074.d.ref

@@ -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;
+}

tests/knr/issue0076.d.ref

@@ -0,0 +1,5 @@
+unittest {
+Label:
+    while (1) {
+    }
+}

tests/knr/issue0079.d.ref

@@ -0,0 +1,8 @@
+unittest {
+    switch (x) {
+    case a: {
+        }
+    case b:
+        return;
+    }
+}

tests/knr/issue0080.d.ref

@@ -0,0 +1,10 @@
+unittest {
+    switch (x) {
+    case a:
+        return;
+        version (A) {
+    case b:
+            return;
+        }
+    }
+}

tests/knr/issue0081.d.ref

@@ -0,0 +1,15 @@
+unittest {
+    if (0)
+        if (0) {
+        } else if (0) {
+        } else {
+        }
+    doSomething();
+}
+
+unittest {
+    if (0)
+        if (0) {
+        }
+    doSomething();
+}

tests/knr/issue0082.d.ref

@@ -0,0 +1,10 @@
+unittest {
+label:
+    if (x) {
+    }
+Label:
+
+    // comment
+    statement();
+}
+}

tests/knr/issue0083.d.ref

@@ -0,0 +1,5 @@
+bool contains(T item)
+{
+    asm pure nothrow @nogc {
+    }
+}

tests/knr/issue0085.d.ref

@@ -0,0 +1 @@
+alias T = typeof(return);

tests/knr/issue0086.d.ref

@@ -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++;
+            }
+}

tests/knr/issue0088.d.ref

@@ -0,0 +1,7 @@
+unittest {
+    switch (x) {
+    case +1:
+    case -1:
+    case (1):
+    }
+}

tests/knr/issue0089.d.ref

@@ -0,0 +1,5 @@
+unittest {
+    if (x)
+        doSomething();
+    //doSomethingElse();
+}

tests/knr/issue0090.d.ref

@@ -0,0 +1,8 @@
+unittest {
+L1:
+    switch (x) {
+    case Case:
+        doSomething();
+        doSomethingElse();
+    }
+}

tests/knr/issue0091.d.ref

@@ -0,0 +1,10 @@
+unittest {
+    switch (x) {
+        version (none) {
+            x();
+    case Case:
+            doSomething();
+            doSomethingElse();
+        }
+    }
+}

tests/knr/issue0092.d.ref

@@ -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;
+    }
+}

tests/knr/issue0093.d.ref

@@ -0,0 +1,7 @@
+unittest {
+    if (x) {
+        version (none) {
+        } else {
+        }
+    }
+}

tests/knr/issue0094.d.ref

@@ -0,0 +1,6 @@
+void test()
+{
+    fun((int x) { writeln(x); }, (int x) { writeln(x); });
+
+    return;
+}

tests/knr/issue0095.d.ref

@@ -0,0 +1,6 @@
+unittest {
+    if (!fdmatch)
+        goto Lfd;
+    {
+    }
+}

tests/knr/issue0096.d.ref

@@ -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();
+}

tests/knr/issue0097.d.ref

@@ -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;
+    }
+}

tests/knr/issue0098.d.ref

@@ -0,0 +1,6 @@
+unittest {
+    if (!fdmatch)
+        goto Lfd; // comment
+    {
+    }
+}

tests/knr/issue0099.d.ref

@@ -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);
+                }
+            }
+        }
+    }
+}

tests/knr/issue0100.d.ref

@@ -0,0 +1,12 @@
+unittest {
+    loop: while (i < tokens.length) switch (tokens[i].type) {
+    case tok!"(":
+        parenDepth++;
+        i++;
+        break;
+    case tok!"{":
+        braceDepth++;
+        i++;
+        break;
+    }
+}

tests/knr/issue0101.d.ref

@@ -0,0 +1,9 @@
+#! /usr/bin/env rdmd
+
+import std.stdio : writeln;
+
+int main(immutable string[] args)
+{
+    writeln("Hello World!");
+    return 0;
+}

tests/knr/issue0102.d.ref

@@ -0,0 +1 @@
+import std.stdio: stderr;