Add tests for --braceStyle=otbs. Fix #101

src/dfmt.d

@@ -307,11 +307,11 @@ private:
         else if ((isBlockHeader() || currentIs(tok!"version") || currentIs(tok!"debug"))
             && peekIs(tok!"(", false))
         {
-			immutable bool a = !currentIs(tok!"version") && !currentIs(tok!"debug") ;
+            immutable bool a = !currentIs(tok!"version") && !currentIs(tok!"debug") ;
-			immutable bool b = a || astInformation.conditionalWithElseLocations
+            immutable bool b = a || astInformation.conditionalWithElseLocations
-				.canFindIndex(current.index);
+                    .canFindIndex(current.index);
-			immutable bool shouldPushIndent = b || astInformation.conditionalStatementLocations
+            immutable bool shouldPushIndent = b || astInformation.conditionalStatementLocations
-				.canFindIndex(current.index);
+                    .canFindIndex(current.index);
             if (shouldPushIndent)
                 indents.push(current.type);
             writeToken();
@@ -432,8 +432,8 @@ private:
                 }
                 goto binary;
             case tok!"(":
-				spaceAfterParens = true;
+                spaceAfterParens = true;
-				writeToken();
+                writeToken();
                 parenDepth++;
                 if (linebreakHints.canFindIndex(index - 1) || (linebreakHints.length == 0
                     && currentLineLength > config.columnSoftLimit && !currentIs(tok!")")))
@@ -443,11 +443,11 @@ private:
                 }
                 regenLineBreakHintsIfNecessary(index - 1);
                 break;
-			case tok!")":
+            case tok!")":
-				parenDepth--;
+                parenDepth--;
-				if (parenDepth == 0)
+                if (parenDepth == 0)
-					while (indents.length > 0 && isWrapIndent(indents.top))
+                    while (indents.length > 0 && isWrapIndent(indents.top))
-						indents.pop();
+                        indents.pop();
                 if (parenDepth == 0 && (peekIs(tok!"in") || peekIs(tok!"out")
                     || peekIs(tok!"body")))
                 {
@@ -468,7 +468,7 @@ private:
                 }
                 else
                     writeToken();
-				break;
+                    break;
             case tok!"!":
                 if (peekIs(tok!"is"))
                     write(" ");
@@ -521,20 +521,20 @@ private:
                     write(" ");
                 break;
             case tok!";":
-				if (parenDepth > 0)
+                if (parenDepth > 0)
-				{
+                {
-					if (!(peekIs(tok!";") || peekIs(tok!")") || peekIs(tok!"}")))
+                    if (!(peekIs(tok!";") || peekIs(tok!")") || peekIs(tok!"}")))
-						write("; ");
+                            write("; ");
-					else
+                    else
-						write(";");
+                            write(";");
-					index++;
+                    index++;
-				}
+                }
-				else
+                else
-				{
+                {
-					writeToken();
+                    writeToken();
-					linebreakHints = [];
+                    linebreakHints = [];
-					newline();
+                    newline();
-				}
+                }
                 break;
             case tok!"{":
                 if (astInformation.structInitStartLocations.canFindIndex(
@@ -558,6 +558,19 @@ private:
                     {
                         if (config.braceStyle == BraceStyle.otbs)
                         {
+                             if (!astInformation.structInitStartLocations.canFindIndex(tokens[index].index)
+                                && !astInformation.funLitStartLocations.canFindIndex(tokens[index].index))
+                            {
+                                while (indents.length && isWrapIndent(indents.top))
+                                    indents.pop();
+                                indents.push(tok!"{");
+                                if (index == 1 || peekBackIs(tok!":", true) || peekBackIs(tok!"{", true)
+                                    || peekBackIs(tok!"}", true) || peekBackIs(tok!")", true)
+                                    || peekBackIs(tok!";", true))
+                                {
+                                    indentLevel = indents.indentSize - 1;
+                                }
+                            }
                             write(" ");
                         }
                         else if (index > 0 && (!peekBackIs(tok!"comment") || tokens[index - 1].text[0 .. 2] != "//"))
@@ -709,6 +722,11 @@ private:
                 write(" ");
             }
         }
+        else if (currentIs(tok!"scriptLine"))
+        {
+            writeToken();
+            newline();
+        }
         else
             writeToken();
     }

tests/allman/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/issue0101.d

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

tests/otbs/DeclSpacing.d.ref

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

tests/otbs/catchExceptionNested.d.ref

@@ -0,0 +1,36 @@
+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/otbs/comments.d.ref

@@ -0,0 +1,6 @@
+int /*sneaky*/ foo( /*comments*/ ) /*everywhere*/ {
+    // comment on its own line
+    foo() // comment on same line
+    .bar(); // also on same line
+    /* again */  // same line
+}

tests/otbs/contracts.d.ref

@@ -0,0 +1,16 @@
+void main(string[] args) {
+    struct SomeStruct {
+    private:
+        int a;
+        int b;
+        void doStuff(int q)
+        in {
+            assert(q);
+        }
+        out (result) {
+        }
+        body {
+            writeln(q);
+        }
+    }
+}

tests/otbs/frontpage.d.ref

@@ -0,0 +1,12 @@
+// 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/otbs/guessnumber.d.ref

@@ -0,0 +1,31 @@
+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/otbs/hello.d.ref

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

tests/otbs/higherorder.d.ref

@@ -0,0 +1,10 @@
+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/otbs/issue0017.d.ref

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

tests/otbs/issue0018.d.ref

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

tests/otbs/issue0021.d.ref

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

tests/otbs/issue0022.d.ref

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

tests/otbs/issue0024.d.ref

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

tests/otbs/issue0025.d.ref

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

tests/otbs/issue0026.d.ref

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

tests/otbs/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/otbs/issue0029.d.ref

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

tests/otbs/issue0030.d.ref

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

tests/otbs/issue0032.d.ref

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

tests/otbs/issue0033.d.ref

@@ -0,0 +1,13 @@
+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/otbs/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/otbs/issue0037.d.ref

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