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

src/dfmt.d

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