Merge pull request #217 from Hackerpilot/indentation-madness

0.5.0 changes

src/dfmt/ast_info.d

@@ -96,7 +96,8 @@ final class FormatVisitor : ASTVisitor
             auto condition = dec.compileCondition;
             if (condition.versionCondition !is null)
             {
-                astInformation.conditionalWithElseLocations ~= condition.versionCondition.versionIndex;
+                astInformation.conditionalWithElseLocations
+                    ~= condition.versionCondition.versionIndex;
             }
             else if (condition.debugCondition !is null)
             {
@@ -151,8 +152,10 @@ final class FormatVisitor : ASTVisitor
     {
         if (functionBody.blockStatement !is null)
             astInformation.doubleNewlineLocations ~= functionBody.blockStatement.endLocation;
-        if (functionBody.bodyStatement !is null && functionBody.bodyStatement.blockStatement !is null)
+        if (functionBody.bodyStatement !is null && functionBody.bodyStatement
-            astInformation.doubleNewlineLocations ~= functionBody.bodyStatement.blockStatement.endLocation;
+                .blockStatement !is null)
+            astInformation.doubleNewlineLocations
+                ~= functionBody.bodyStatement.blockStatement.endLocation;
         functionBody.accept(this);
     }
 
@@ -203,8 +206,8 @@ final class FormatVisitor : ASTVisitor
     override void visit(const UnaryExpression unary)
     {
         if (unary.prefix.type == tok!"~" || unary.prefix.type == tok!"&"
-                || unary.prefix.type == tok!"*" || unary.prefix.type == tok!"+"
+                || unary.prefix.type == tok!"*"
-                || unary.prefix.type == tok!"-")
+                || unary.prefix.type == tok!"+" || unary.prefix.type == tok!"-")
         {
             astInformation.unaryLocations ~= unary.prefix.index;
         }

src/dfmt/config.d

@@ -54,7 +54,6 @@ struct Config
 
     mixin StandardEditorConfigFields;
 
-
     /**
      * Initializes the standard EditorConfig properties with default values that
      * make sense for D code.
@@ -89,7 +88,8 @@ struct Config
 
         if (dfmt_soft_max_line_length > max_line_length)
         {
-            stderr.writefln("Column hard limit (%d) must be greater than or equal to column soft limit (%d)",
+            stderr.writefln(
+                "Column hard limit (%d) must be greater than or equal to column soft limit (%d)",
                     max_line_length, dfmt_soft_max_line_length);
             return false;
         }

src/dfmt/editorconfig.d

@@ -73,11 +73,11 @@ mixin template StandardEditorConfigFields()
             auto thisN = &mixin("this." ~ N);
             static if (N == "pattern")
                 continue;
-            else static if (is (T == enum))
+            else static if (is(T == enum))
                 *thisN = otherN != T.unspecified ? otherN : *thisN;
-            else static if (is (T == int))
+            else static if (is(T == int))
                 *thisN = otherN != -1 ? otherN : *thisN;
-            else static if (is (T == string))
+            else static if (is(T == string))
                 *thisN = otherN !is null ? otherN : *thisN;
             else
                 static assert(false);
@@ -143,6 +143,7 @@ EC getConfigFor(EC)(string path)
     static if (__VERSION__ >= 2067)
     {
         import std.algorithm : each;
+
         configs.each!(a => a.each!(b => result.merge(b, fileName)))();
     }
     else

src/dfmt/formatter.d

@@ -351,7 +351,7 @@ private:
                     indents.pop();
                 else if (peekBack2Is(tok!",") && !indents.topIs(tok!",")
                         && indents.indentToMostRecent(tok!"enum") == -1)
-                    indents.push(tok!",");
+                    pushWrapIndent(tok!",");
                 newline();
             }
         }
@@ -440,11 +440,12 @@ private:
     }
     body
     {
-        immutable p = tokens[index].type;
+        immutable p = current.type;
         regenLineBreakHintsIfNecessary(index);
         writeToken();
         if (p == tok!"(")
         {
+            indents.push(p);
             spaceAfterParens = true;
             parenDepth++;
         }
@@ -454,7 +455,7 @@ private:
         if (arrayInitializerStart)
         {
             // Use the close bracket as the indent token to distinguish
-            // the array initialiazer from an array index in the newling
+            // the array initialiazer from an array index in the newline
             // handling code
             pushWrapIndent(tok!"]");
             newline();
@@ -466,7 +467,6 @@ private:
                 && (linebreakHints.canFindIndex(index - 1)
                     || (linebreakHints.length == 0 && currentLineLength > config.max_line_length)))
         {
-            pushWrapIndent(p);
             newline();
         }
     }
@@ -479,8 +479,9 @@ private:
     body
     {
         parenDepth--;
-        if (parenDepth == 0)
         indents.popWrapIndents();
+        if (indents.topIs(tok!"("))
+            indents.pop();
 
         if (parenDepth == 0 && (peekIs(tok!"is") || peekIs(tok!"in")
                 || peekIs(tok!"out") || peekIs(tok!"body")))
@@ -505,17 +506,13 @@ private:
                 immutable l = currentLineLength + betweenParenLength(tokens[index + 1 .. $]);
                 if (l > config.dfmt_soft_max_line_length)
                 {
-                    // The order of these two calls is intentional
                     newline();
-                    pushWrapIndent(tok!"!");
                 }
                 else
                     write(" ");
                 break;
             case always_newline:
-                // The order of these two calls is intentional
                 newline();
-                pushWrapIndent(tok!"!");
                 break;
             case conditional_newline_indent:
                 immutable l = currentLineLength + betweenParenLength(tokens[index + 1 .. $]);
@@ -801,6 +798,8 @@ private:
 
     void formatBlockHeader()
     {
+        if (indents.topIs(tok!"!"))
+            indents.pop();
         immutable bool a = !currentIs(tok!"version") && !currentIs(tok!"debug");
         immutable bool b = a
             || astInformation.conditionalWithElseLocations.canFindIndex(current.index);
@@ -1152,8 +1151,8 @@ private:
                 || (linebreakHints.length == 0
                     && currentLineLength > config.dfmt_soft_max_line_length)))
         {
+            pushWrapIndent();
             writeToken();
-            pushWrapIndent(tok!",");
             newline();
         }
         else
@@ -1271,6 +1270,12 @@ private:
                     indentLevel = config.dfmt_align_switch_statements
                         == OptionalBoolean.t ? l : indents.indentLevel;
             }
+            else if (currentIs(tok!")"))
+            {
+                if (indents.topIs(tok!"("))
+                    indents.pop();
+                indentLevel = indents.indentLevel;
+            }
             else if (currentIs(tok!"{"))
             {
                 indents.popWrapIndents();
@@ -1378,7 +1383,7 @@ private:
             {
                 if (currentLineLength >= config.dfmt_soft_max_line_length)
                 {
-                    pushWrapIndent(tok!";");
+                    pushWrapIndent();
                     writeToken();
                     newline();
                 }

src/dfmt/globmatch_editorconfig.d

@@ -10,15 +10,15 @@ import std.path : filenameCharCmp, isDirSeparator;
 // From std.path with changes:
 // * changes meaning to match all characters except '/'
 // ** added to take over the old meaning of *
-bool globMatchEditorConfig(CaseSensitive cs = CaseSensitive.osDefault, C, Range)
+bool globMatchEditorConfig(CaseSensitive cs = CaseSensitive.osDefault, C, Range)(
-(Range path, const(C)[] pattern)
+    Range path, const(C)[] pattern) @safe pure nothrow if (isForwardRange!Range
-@safe pure nothrow
+        && isSomeChar!(ElementEncodingType!Range) && isSomeChar!C
-if (isForwardRange!Range && isSomeChar!(ElementEncodingType!Range) &&
+        && is(Unqual!C == Unqual!(ElementEncodingType!Range)))
-    isSomeChar!C && is(Unqual!C == Unqual!(ElementEncodingType!Range)))
 in
 {
     // Verify that pattern[] is valid
     import std.algorithm : balancedParens;
+
     assert(balancedParens(pattern, '[', ']', 0));
     assert(balancedParens(pattern, '{', '}', 0));
 }
@@ -29,11 +29,13 @@ body
     static if (RC.sizeof == 1 && isSomeString!Range)
     {
         import std.utf : byChar;
+
         return globMatchEditorConfig!cs(path.byChar, pattern);
     }
     else static if (RC.sizeof == 2 && isSomeString!Range)
     {
         import std.utf : byWchar;
+
         return globMatchEditorConfig!cs(path.byWchar, pattern);
     }
     else
@@ -45,15 +47,14 @@ body
             switch (pc)
             {
             case '*':
-                    if (pi < pattern.length-1 && pattern[pi+1] == '*')
+                if (pi < pattern.length - 1 && pattern[pi + 1] == '*')
                 {
                     if (pi + 2 == pattern.length)
                         return true;
                     for (; !path.empty; path.popFront())
                     {
                         auto p = path.save;
-                            if (globMatchEditorConfig!(cs, C)(p,
+                        if (globMatchEditorConfig!(cs, C)(p, pattern[pi + 2 .. pattern.length]))
-                                                  pattern[pi + 2 .. pattern.length]))
                             return true;
                     }
                     return false;
@@ -67,8 +68,7 @@ body
                         auto p = path.save;
                         //if (p[0].to!dchar.isDirSeparator() && !pattern[pi+1].isDirSeparator())
                         //    return false;
-                            if (globMatchEditorConfig!(cs, C)(p,
+                        if (globMatchEditorConfig!(cs, C)(p, pattern[pi + 1 .. pattern.length]))
-                                                  pattern[pi + 1 .. pattern.length]))
                             return true;
                         if (p[0].to!dchar.isDirSeparator())
                             return false;
@@ -110,9 +110,9 @@ body
             case '{':
                 // find end of {} section
                 auto piRemain = pi;
-                    for (; piRemain < pattern.length
+                for (; piRemain < pattern.length && pattern[piRemain] != '}'; ++piRemain)
-                         && pattern[piRemain] != '}'; ++piRemain)
+                {
-                    {   }
+                }
 
                 if (piRemain < pattern.length)
                     ++piRemain;
@@ -131,7 +131,7 @@ body
                     auto p = path.save;
                     if (pi0 == pi)
                     {
-                            if (globMatchEditorConfig!(cs, C)(p, pattern[piRemain..$]))
+                        if (globMatchEditorConfig!(cs, C)(p, pattern[piRemain .. $]))
                         {
                             return true;
                         }
@@ -142,8 +142,7 @@ body
                         /* Match for:
                             *   pattern[pi0..pi-1] ~ pattern[piRemain..$]
                             */
-                            if (pattmp.ptr == null)
+                        if (pattmp.ptr == null) // Allocate this only once per function invocation.
-                                // Allocate this only once per function invocation.
                             // Should do it with malloc/free, but that would make it impure.
                             pattmp = new C[pattern.length];
 
@@ -180,8 +179,8 @@ body
 
 unittest
 {
-    assert (globMatchEditorConfig!(CaseSensitive.no)("foo", "Foo"));
+    assert(globMatchEditorConfig!(CaseSensitive.no)("foo", "Foo"));
-    assert (!globMatchEditorConfig!(CaseSensitive.yes)("foo", "Foo"));
+    assert(!globMatchEditorConfig!(CaseSensitive.yes)("foo", "Foo"));
 
     assert(globMatchEditorConfig("foo", "*"));
     assert(globMatchEditorConfig("foo.bar"w, "*"w));
@@ -225,7 +224,7 @@ unittest
     assert(!globMatchEditorConfig("foo", "foob"));
     assert(!globMatchEditorConfig("foo", "foo{b}"));
 
-    assert (globMatchEditorConfig(`foo/foo\bar`, "f**b**r"));
+    assert(globMatchEditorConfig(`foo/foo\bar`, "f**b**r"));
     assert(globMatchEditorConfig("foo", "**"));
     assert(globMatchEditorConfig("foo/bar", "foo/bar"));
     assert(globMatchEditorConfig("foo/bar", "foo/*"));
@@ -235,6 +234,5 @@ unittest
     assert(!globMatchEditorConfig("/foo/bar/gluu/sar.png", "*/sar.png"));
     assert(!globMatchEditorConfig("/foo/bar/gluu/sar.png", "*/*.png"));
 
-
     static assert(globMatchEditorConfig("foo.bar", "[!gh]*bar"));
 }

src/dfmt/indentation.d

@@ -13,7 +13,7 @@ import dparse.lexer;
 bool isWrapIndent(IdType type) pure nothrow @nogc @safe
 {
     return type != tok!"{" && type != tok!"case" && type != tok!"@"
-		&& type != tok!"]" && isOperator(type);
+        && type != tok!"]" && type != tok!"(" && isOperator(type);
 }
 
 /**
@@ -30,8 +30,7 @@ bool isTempIndent(IdType type) pure nothrow @nogc @safe
 struct IndentStack
 {
     /**
-     * Modifies the indent stack to match the state that it had at the most
+     * Get the indent size at the most recent occurence of the given indent type
-     * recent appearance of the given token type.
      */
     int indentToMostRecent(IdType item) const
     {
@@ -152,6 +151,15 @@ struct IndentStack
         return cast(int) index;
     }
 
+    /+void dump()
+    {
+        import std.stdio : stderr;
+        import dparse.lexer : str;
+        import std.algorithm.iteration : map;
+
+        stderr.writefln("\033[31m%(%s %)\033[0m", arr[0 .. index].map!(a => str(a)));
+    }+/
+
 private:
 
     size_t index;
@@ -164,18 +172,32 @@ private:
             return 0;
         immutable size_t j = k == size_t.max ? index : k;
         int size = 0;
+        int parenCount;
         foreach (i; 0 .. j)
         {
             if (i + 1 < index)
             {
-                if (arr[i] == tok!"]")
+                if (arr[i] == tok!"(")
+                    parenCount++;
+                else if (arr[i] == tok!"]")
                     continue;
-                immutable bool currentIsTemp = isTempIndent(arr[i]);
+                else
-                immutable bool nextIsTemp = isTempIndent(arr[i + 1]);
+                {
-                immutable bool nextIsSwitch = arr[i + 1] == tok!"switch";
+                    if (isWrapIndent(arr[i]) && parenCount > 0)
-                if (currentIsTemp && (!nextIsTemp || nextIsSwitch))
+                    {
+                        parenCount = 0;
                         continue;
                     }
+                    parenCount = 0;
+                }
+                immutable currentIsNonWrapTemp = !isWrapIndent(arr[i]) && isTempIndent(arr[i]);
+                immutable nextIsParenOrSwitch = arr[i + 1] == tok!"("
+                    || arr[i + 1] == tok!"switch" || arr[i + 1] == tok!"{";
+                if (currentIsNonWrapTemp && nextIsParenOrSwitch)
+                    continue;
+            }
+            if (arr[i] == tok!"!")
+                size++;
             size++;
         }
         return size;

src/dfmt/main.d

@@ -5,7 +5,7 @@
 
 module dfmt.main;
 
-private enum VERSION = "0.4.5";
+private enum VERSION = "0.5.0";
 
 version (NoMain)
 {
@@ -32,8 +32,10 @@ else
         {
             import dfmt.editorconfig : OptionalBoolean;
             import std.exception : enforceEx;
+
             enforceEx!GetOptException(value == "true" || value == "false", "Invalid argument");
-            immutable OptionalBoolean optVal = value == "true" ? OptionalBoolean.t : OptionalBoolean.f;
+            immutable OptionalBoolean optVal = value == "true" ? OptionalBoolean.t
+                : OptionalBoolean.f;
             switch (option)
             {
             case "align_switch_statements":
@@ -54,7 +56,8 @@ else
             case "compact_labeled_statements":
                 optConfig.dfmt_compact_labeled_statements = optVal;
                 break;
-            default: assert(false, "Invalid command-line switch");
+            default:
+                assert(false, "Invalid command-line switch");
             }
         }
 
@@ -113,17 +116,19 @@ else
             return 1;
 
         File output = stdout;
-        version(Windows)
+        version (Windows)
         {
             // On Windows, set stdout to binary mode (needed for correct EOL writing)
             // See Phobos' stdio.File.rawWrite
             {
                 import std.stdio;
+
                 immutable fd = fileno(output.getFP());
                 setmode(fd, _O_BINARY);
-                version(CRuntime_DigitalMars)
+                version (CRuntime_DigitalMars)
                 {
                     import core.atomic : atomicOp;
+
                     atomicOp!"&="(__fhnd_info[fd], ~FHND_TEXT);
                 }
             }
@@ -176,14 +181,17 @@ else
     }
 }
 
-private string optionsToString(E)() if(is(E == enum)) {
+private string optionsToString(E)() if (is(E == enum))
-	import std.traits:EnumMembers;
+{
+    import std.traits : EnumMembers;
     import std.conv;
+
     string result = "[";
-	foreach(i, option; EnumMembers!E) {
+    foreach (i, option; EnumMembers!E)
+    {
         result ~= to!string(option) ~ "|";
     }
-	result = result[0 .. $-1] ~ "]";
+    result = result[0 .. $ - 1] ~ "]";
     return result;
 }
 
@@ -199,11 +207,13 @@ Options:
 
 Formatting Options:
     --align_switch_statements
-    --brace_style	`, optionsToString!(typeof(Config.dfmt_brace_style))(), `
+    --brace_style	`,
+            optionsToString!(typeof(Config.dfmt_brace_style))(), `
     --end_of_line
     --help|h
     --indent_size
-    --indent_style|t	`, optionsToString!(typeof(Config.indent_style))(), `
+    --indent_style|t	`,
+            optionsToString!(typeof(Config.indent_style))(), `
     --soft_max_line_length
     --max_line_length
     --outdent_attributes
@@ -211,7 +221,8 @@ Formatting Options:
     --selective_import_space
     --split_operator_at_line_end
     --compact_labeled_statements
-    --template_constraint_style	`, optionsToString!(typeof(Config.dfmt_template_constraint_style))());
+    --template_constraint_style	`,
+            optionsToString!(typeof(Config.dfmt_template_constraint_style))());
 }
 
 private string createFilePath(bool readFromStdin, string fileName)

src/dfmt/tokens.d

@@ -195,7 +195,6 @@ pure nothrow @safe @nogc unittest
             assert(breakCost(tok!".", u) != 1000);
 }
 
-
 private string generateFixedLengthCases()
 {
     import std.algorithm : map;
@@ -205,11 +204,11 @@ private string generateFixedLengthCases()
     assert(__ctfe);
 
     string[] spacedOperatorTokens = [
-        ",", "..", "...", "/", "/=", "!", "!<", "!<=", "!<>", "!<>=", "!=", "!>",
+        ",", "..", "...", "/", "/=", "!", "!<", "!<=", "!<>", "!<>=", "!=",
-        "!>=", "%", "%=", "&", "&&", "&=", "*", "*=", "+", "+=", "-", "-=", ":",
+        "!>", "!>=", "%", "%=", "&", "&&", "&=", "*", "*=", "+", "+=", "-",
-        ";", "<", "<<", "<<=", "<=", "<>", "<>=", "=", "==", "=>", ">", ">=",
+        "-=", ":", ";", "<", "<<", "<<=", "<=", "<>", "<>=", "=", "==", "=>",
-        ">>", ">>=", ">>>", ">>>=", "?", "@", "^", "^=", "^^", "^^=", "|", "|=", "||",
+        ">", ">=", ">>", ">>=", ">>>", ">>>=", "?", "@", "^", "^=", "^^",
-        "~", "~="
+        "^^=", "|", "|=", "||", "~", "~="
     ];
     immutable spacedOperatorTokenCases = spacedOperatorTokens.map!(
         a => format(`case tok!"%s": return %d + 1;`, a, a.length)).join("\n\t");
@@ -219,20 +218,21 @@ private string generateFixedLengthCases()
         "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",
+        "enum", "export", "extern", "false", "final", "finally", "float",
-        "foreach", "foreach_reverse", "function", "goto", "idouble", "if",
+        "for", "foreach", "foreach_reverse", "function", "goto", "idouble",
-        "ifloat", "immutable", "import", "in", "inout", "int", "interface",
+        "if", "ifloat", "immutable", "import", "in", "inout", "int",
-        "invariant", "ireal", "is", "lazy", "long", "macro", "mixin", "module",
+        "interface", "invariant", "ireal", "is", "lazy", "long", "macro",
-        "new", "nothrow", "null", "out", "override", "package", "pragma",
+        "mixin", "module", "new", "nothrow", "null", "out", "override",
-        "private", "protected", "public", "pure", "real", "ref", "return",
+        "package", "pragma", "private", "protected", "public", "pure", "real",
-        "scope", "shared", "short", "static", "struct", "super", "switch",
+        "ref", "return", "scope", "shared", "short", "static", "struct",
-        "synchronized", "template", "this", "throw", "true", "try", "typedef",
+        "super", "switch", "synchronized", "template", "this", "throw", "true",
-        "typeid", "typeof", "ubyte", "ucent", "uint", "ulong", "union",
+        "try", "typedef", "typeid", "typeof", "ubyte", "ucent", "uint",
-        "unittest", "ushort", "version", "void", "volatile", "wchar", "while",
+        "ulong", "union", "unittest", "ushort", "version", "void", "volatile",
-        "with", "__DATE__", "__EOF__", "__FILE__", "__FUNCTION__", "__gshared",
+        "wchar", "while", "with", "__DATE__", "__EOF__", "__FILE__",
-        "__LINE__", "__MODULE__", "__parameters", "__PRETTY_FUNCTION__",
+        "__FUNCTION__", "__gshared", "__LINE__", "__MODULE__", "__parameters",
-        "__TIME__", "__TIMESTAMP__", "__traits", "__vector", "__VENDOR__",
+        "__PRETTY_FUNCTION__", "__TIME__", "__TIMESTAMP__", "__traits",
-        "__VERSION__", "$", "++", "--", ".", "[", "]", "(", ")", "{", "}"
+        "__vector", "__VENDOR__", "__VERSION__", "$", "++", "--", ".", "[",
+        "]", "(", ")", "{", "}"
     ];
     immutable identifierTokenCases = identifierTokens.map!(
         a => format(`case tok!"%s": return %d;`, a, a.length)).join("\n\t");

src/dfmt/wrapping.d

@@ -18,7 +18,8 @@ struct State
         import core.bitop : popcnt, bsf;
         import std.algorithm : min, map, sum;
 
-        immutable int remainingCharsMultiplier = config.max_line_length - config.dfmt_soft_max_line_length;
+        immutable int remainingCharsMultiplier = config.max_line_length
+            - config.dfmt_soft_max_line_length;
         immutable int newlinePenalty = remainingCharsMultiplier * 20;
 
         this.breaks = breaks;
@@ -152,7 +153,8 @@ size_t[] chooseLineBreakTokens(size_t index, const Token[] tokens,
             return genRetVal(current.breaks, index);
         }
         validMoves!(typeof(open))(open, tokens[0 .. tokensEnd],
-            depths[0 .. tokensEnd], current.breaks, config, currentLineLength, indentLevel);
+                depths[0 .. tokensEnd], current.breaks, config, currentLineLength,
+                indentLevel);
     }
     if (open.empty)
         return genRetVal(lowest.breaks, index);

tests/allman/issue0111.d.ref

@@ -1,8 +1,9 @@
 struct Test
 {
     this(string name, string[] aliasList, string briefDescription, string examDesc,
-        string onOpenDesc, string openDesc, string onCloseDesc, string closeDesc,
+            string onOpenDesc, string openDesc, string onCloseDesc,
-        Flag!"canOpen" canOpen, Flag!"canClose" canClose, Flag!"isOpen" isOpen)
+            string closeDesc, Flag!"canOpen" canOpen, Flag!"canClose" canClose,
+            Flag!"isOpen" isOpen)
     {
     }
 }

tests/allman/parenIndent.d.ref

@@ -0,0 +1,36 @@
+unittest
+{
+    if (a)
+    {
+        while (sBraceDepth == 0 && indents.topIsTemp()
+                && ((indents.top != tok!"if" && indents.top != tok!"version")
+                    || !peekIs(tok!"else")))
+        {
+            a();
+        }
+    }
+
+    if (parenDepth == 0 && (peekIs(tok!"is") || peekIs(tok!"in")
+            || peekIs(tok!"out") || peekIs(tok!"body")))
+        writeToken();
+
+    {
+        {
+            while (sBraceDepth == 0 && indents.topIsTemp()
+                    && ((indents.top != tok!"if"
+                        && indents.top != tok!"version") || !peekIs(tok!"else")))
+            {
+                indents.pop();
+            }
+        }
+    }
+
+    {
+        while (sBraceDepth == 0 && indents.topIsTemp()
+                && ((indents.top != tok!"if" && indents.top != tok!"version")
+                    || !peekIs(tok!"else")))
+        {
+            indents.pop();
+        }
+    }
+}

tests/otbs/issue0111.d.ref

@@ -1,6 +1,7 @@
 struct Test {
     this(string name, string[] aliasList, string briefDescription, string examDesc,
-        string onOpenDesc, string openDesc, string onCloseDesc, string closeDesc,
+            string onOpenDesc, string openDesc, string onCloseDesc,
-        Flag!"canOpen" canOpen, Flag!"canClose" canClose, Flag!"isOpen" isOpen) {
+            string closeDesc, Flag!"canOpen" canOpen, Flag!"canClose" canClose,
+            Flag!"isOpen" isOpen) {
     }
 }

tests/otbs/parenIndent.d.ref

@@ -0,0 +1,31 @@
+unittest {
+    if (a) {
+        while (sBraceDepth == 0 && indents.topIsTemp()
+                && ((indents.top != tok!"if" && indents.top != tok!"version")
+                    || !peekIs(tok!"else"))) {
+            a();
+        }
+    }
+
+    if (parenDepth == 0 && (peekIs(tok!"is") || peekIs(tok!"in")
+            || peekIs(tok!"out") || peekIs(tok!"body")))
+        writeToken();
+
+    {
+        {
+            while (sBraceDepth == 0 && indents.topIsTemp()
+                    && ((indents.top != tok!"if"
+                        && indents.top != tok!"version") || !peekIs(tok!"else"))) {
+                indents.pop();
+            }
+        }
+    }
+
+    {
+        while (sBraceDepth == 0 && indents.topIsTemp()
+                && ((indents.top != tok!"if" && indents.top != tok!"version")
+                    || !peekIs(tok!"else"))) {
+            indents.pop();
+        }
+    }
+}

tests/parenIndent.d

@@ -0,0 +1,32 @@
+unittest
+{
+	if (a)
+	{
+		while (sBraceDepth == 0 && indents.topIsTemp()
+		&& ((indents.top != tok!"if" && indents.top != tok!"version")|| !peekIs(tok!"else")))
+		{
+			a();
+		}
+	}
+
+	if (parenDepth == 0 && (peekIs(tok!"is") || peekIs(tok!"in")
+			|| peekIs(tok!"out") || peekIs(tok!"body")))
+		writeToken();
+
+	{
+		{
+			while (sBraceDepth == 0 && indents.topIsTemp()&& ((indents.top != tok!"if"
+&& indents.top != tok!"version") || !peekIs(tok!"else")))
+			{
+				indents.pop();
+			}
+		}
+	}
+
+	{
+		while (sBraceDepth == 0 && indents.topIsTemp()&& ((indents.top != tok!"if" && indents.top != tok!"version")			|| !peekIs(tok!"else")))
+		{
+			indents.pop();
+		}
+	}
+}

tests/test

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-for braceStyle in allman otbs
-do
-	for source in *.d
-	do
-		echo "${source}.ref" "${braceStyle}/${source}.out"
-		argsFile=$(basename ${source} .d).args
-		if [ -e ${argsFile} ]; then
-			args=$(cat ${argsFile})
-		else
-			args=
-		fi
-		../bin/dfmt --brace_style=${braceStyle} ${args} "${source}" > "${braceStyle}/${source}.out"
-		diff -u "${braceStyle}/${source}.ref" "${braceStyle}/${source}.out"
-	done
-done